Efekt wykonania komendy 'c++ -v --help'

Usage: c++ [options] file...
Options:
  -pass-exit-codes         Exit with highest error code from a phase
  --help                   Display this information
  --target-help            Display target specific command line options
  --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...]
                           Display specific types of command line options
  --version                Display compiler version information
  -dumpspecs               Display all of the built in spec strings
  -dumpversion             Display the version of the compiler
  -dumpmachine             Display the compiler's target processor
  -print-search-dirs       Display the directories in the compiler's search path
  -print-libgcc-file-name  Display the name of the compiler's companion library
  -print-file-name=<lib>   Display the full path to library <lib>
  -print-prog-name=<prog>  Display the full path to compiler component <prog>
  -print-multiarch         Display the target's normalized GNU triplet, used as
                           a component in the library path
  -print-multi-directory   Display the root directory for versions of libgcc
  -print-multi-lib         Display the mapping between command line options and
                           multiple library search directories
  -print-multi-os-directory Display the relative path to OS libraries
  -print-sysroot           Display the target libraries directory
  -print-sysroot-headers-suffix Display the sysroot suffix used to find headers
  -Wa,<options>            Pass comma-separated <options> on to the assembler
  -Wp,<options>            Pass comma-separated <options> on to the preprocessor
  -Wl,<options>            Pass comma-separated <options> on to the linker
  -Xassembler <arg>        Pass <arg> on to the assembler
  -Xpreprocessor <arg>     Pass <arg> on to the preprocessor
  -Xlinker <arg>           Pass <arg> on to the linker
  -save-temps              Do not delete intermediate files
  -save-temps=<arg>        Do not delete intermediate files
  -no-canonical-prefixes   Do not canonicalize paths when building relative
                           prefixes to other gcc components
  -pipe                    Use pipes rather than intermediate files
  -time                    Time the execution of each subprocess
  -specs=<file>            Override built-in specs with the contents of <file>
  -std=<standard>          Assume that the input sources are for <standard>
  --sysroot=<directory>    Use <directory> as the root directory for headers
                           and libraries
  -B <directory>           Add <directory> to the compiler's search paths
  -v                       Display the programs invoked by the compiler
  -###                     Like -v but options quoted and commands not executed
  -E                       Preprocess only; do not compile, assemble or link
  -S                       Compile only; do not assemble or link
  -c                       Compile and assemble, but do not link
  -o <file>                Place the output into <file>
  -pie                     Create a position independent executable
  -shared                  Create a shared library
  -x <language>            Specify the language of the following input files
                           Permissible languages include: c c++ assembler none
                           'none' means revert to the default behavior of
                           guessing the language based on the file's extension

Options starting with -g, -f, -m, -O, -W, or --param are automatically
 passed on to the various sub-processes invoked by c++.  In order to pass
 other options on to these processes the -W<letter> options must be used.

The following options are specific to just the language Ada:
 None found.  Use --help=Ada to show *all* the options supported by the Ada front-end

The following options are specific to just the language AdaSCIL:
 None found.  Use --help=AdaSCIL to show *all* the options supported by the AdaSCIL front-end

The following options are specific to just the language AdaWhy:
 None found.  Use --help=AdaWhy to show *all* the options supported by the AdaWhy front-end

The following options are specific to just the language C:
  -lang-asm                   This switch lacks documentation

The following options are specific to just the language C++:
 None found.  Use --help=C++ to show *all* the options supported by the C++ front-end

The following options are specific to just the language Fortran:
  -J<directory>               Put MODULE files in 'directory'
  -Waliasing                  Warn about possible aliasing of dummy arguments
  -Walign-commons             Warn about alignment of COMMON blocks
  -Wampersand                 Warn about missing ampersand in continued
                              character constants
  -Warray-temporaries         Warn about creation of array temporaries
  -Wc-binding-type            Warn if the type of a variable might be not
                              interoperable with C
  -Wcharacter-truncation      Warn about truncated character expressions
  -Wcompare-reals             Warn about equality comparisons involving REAL or
                              COMPLEX expressions
  -Wconversion-extra          Warn about most implicit conversions
  -Wextra                     Print extra (possibly unwanted) warnings
  -Wfunction-elimination      Warn about function call elimination
  -Wimplicit-interface        Warn about calls with implicit interface
  -Wimplicit-procedure        Warn about called procedures not explicitly
                              declared
  -Wintrinsic-shadow          Warn if a user-procedure has the same name as an
                              intrinsic
  -Wintrinsics-std            Warn on intrinsics not part of the selected
                              standard
  -Wline-truncation           Warn about truncated source lines
  -Wreal-q-constant           Warn about real-literal-constants with 'q'
                              exponent-letter
  -Wrealloc-lhs               Warn when a left-hand-side array variable is
                              reallocated
  -Wrealloc-lhs-all           Warn when a left-hand-side variable is reallocated
  -Wsurprising                Warn about "suspicious" constructs
  -Wtabs                      Permit nonconforming uses of the tab character
  -Wtarget-lifetime           Warn if the pointer in a pointer assignment might
                              outlive its target
  -Wunderflow                 Warn about underflow of numerical constant
                              expressions
  -Wunused-dummy-argument     Warn about unused dummy arguments.
  -cpp                        Enable preprocessing
  -cpp=                       This switch lacks documentation
  -faggressive-function-elimination Eliminate multiple function invokations
                              also for impure functions
  -falign-commons             Enable alignment of COMMON blocks
  -fall-intrinsics            All intrinsics procedures are available
                              regardless of selected standard
  -fallow-leading-underscore  This switch lacks documentation
  -fautomatic                 Do not treat local variables and COMMON blocks as
                              if they were named in SAVE statements
  -fbackslash                 Specify that backslash in string introduces an
                              escape character
  -fbacktrace                 Produce a backtrace when a runtime error is
                              encountered
  -fblas-matmul-limit=<n>     Size of the smallest matrix for which matmul will
                              use BLAS
  -fcheck-array-temporaries   Produce a warning at runtime if a array temporary
                              has been created for a procedure argument
  -fcheck=[...]               Specify which runtime checks are to be performed
  -fcoarray=[...]             Specify which coarray parallelization should be
                              used
  -fconvert=big-endian        Use big-endian format for unformatted files
  -fconvert=little-endian     Use little-endian format for unformatted files
  -fconvert=native            Use native format for unformatted files
  -fconvert=swap              Swap endianness for unformatted files
  -fcray-pointer              Use the Cray Pointer extension
  -fd-lines-as-code           Ignore 'D' in column one in fixed form
  -fd-lines-as-comments       Treat lines with 'D' in column one as comments
  -fdefault-double-8          Set the default double precision kind to an 8
                              byte wide type
  -fdefault-integer-8         Set the default integer kind to an 8 byte wide
                              type
  -fdefault-real-8            Set the default real kind to an 8 byte wide type
  -fdollar-ok                 Allow dollar signs in entity names
  -fdump-core                 Does nothing. Preserved for backward
                              compatibility.
  -fdump-fortran-optimized    Display the code tree after front end optimization
  -fdump-fortran-original     Display the code tree after parsing
  -fdump-parse-tree           Display the code tree after parsing; deprecated
                              option
  -fexternal-blas             Specify that an external BLAS library should be
                              used for matmul calls on large-size arrays
  -ff2c                       Use f2c calling convention
  -ffixed-form                Assume that the source file is fixed form
  -ffixed-line-length-<n>     Use n as character line width in fixed mode
  -ffixed-line-length-none    Allow arbitrary character line width in fixed mode
  -ffpe-trap=[...]            Stop on following floating point exceptions
  -ffree-form                 Assume that the source file is free form
  -ffree-line-length-<n>      Use n as character line width in free mode
  -ffree-line-length-none     Allow arbitrary character line width in free mode
  -ffrontend-optimize         Enable front end optimization
  -fimplicit-none             Specify that no implicit typing is allowed,
                              unless overridden by explicit IMPLICIT statements
  -finit-character=<n>        Initialize local character variables to ASCII
                              value n
  -finit-integer=<n>          Initialize local integer variables to n
  -finit-local-zero           Initialize local variables to zero (from g77)
  -finit-logical=<true|false> Initialize local logical variables
  -finit-real=<zero|nan|inf|-inf> Initialize local real variables
  -finteger-4-integer-8       Interpret any INTEGER(4) as an INTEGER(8)
  -fintrinsic-modules-path    Specify where to find the compiled intrinsic
                              modules
  -fintrinsic-modules-path=   Specify where to find the compiled intrinsic
                              modules
  -fmax-array-constructor=<n> Maximum number of objects in an array constructor
  -fmax-identifier-length=<n> Maximum identifier length
  -fmax-stack-var-size=<n>    Size in bytes of the largest array that will be
                              put on the stack
  -fmax-subrecord-length=<n>  Maximum length for subrecords
  -fmodule-private            Set default accessibility of module entities to
                              PRIVATE.
  -fpack-derived              Try to lay out derived types as compactly as
                              possible
  -fprotect-parens            Protect parentheses in expressions
  -frange-check               Enable range checking during compilation
  -freal-4-real-10            Interpret any REAL(4) as a REAL(10)
  -freal-4-real-16            Interpret any REAL(4) as a REAL(16)
  -freal-4-real-8             Interpret any REAL(4) as a REAL(8)
  -freal-8-real-10            Interpret any REAL(8) as a REAL(10)
  -freal-8-real-16            Interpret any REAL(8) as a REAL(16)
  -freal-8-real-4             Interpret any REAL(8) as a REAL(4)
  -frealloc-lhs               Reallocate the LHS in assignments
  -frecord-marker=4           Use a 4-byte record marker for unformatted files
  -frecord-marker=8           Use an 8-byte record marker for unformatted files
  -frecursive                 Allocate local variables on the stack to allow
                              indirect recursion
  -frepack-arrays             Copy array sections into a contiguous block on
                              procedure entry
  -fsecond-underscore         Append a second underscore if the name already
                              contains an underscore
  -fsign-zero                 Apply negative sign to zero values
  -fstack-arrays              Put all local arrays on stack.
  -funderscoring              Append underscores to externally visible names
  -fwhole-file                Compile all program units at once and check all
                              interfaces
  -nocpp                      Disable preprocessing
  -static-libgfortran         Statically link the GNU Fortran helper library
                              (libgfortran)
  -std=f2003                  Conform to the ISO Fortran 2003 standard
  -std=f2008                  Conform to the ISO Fortran 2008 standard
  -std=f2008ts                Conform to the ISO Fortran 2008 standard
                              including TS 29113
  -std=f95                    Conform to the ISO Fortran 95 standard
  -std=gnu                    Conform to nothing in particular
  -std=legacy                 Accept extensions to support legacy code

The following options are specific to just the language Go:
  -L                          This switch lacks documentation
  -fgo-check-divide-overflow  Add explicit checks for division overflow in
                              INT_MIN / -1
  -fgo-check-divide-zero      Add explicit checks for division by zero
  -fgo-dump-<type>            Dump Go frontend internal information
  -fgo-optimize-<type>        Turn on optimization passes in the frontend
  -fgo-pkgpath=<string>       Set Go package path
  -fgo-prefix=<string>        Set package-specific prefix for exported Go names
  -fgo-relative-import-path=  -fgo-relative-import-path=<path> Treat a relative
                              import as relative to path
  -frequire-return-statement  Functions which return values must end with
                              return statements

The following options are specific to just the language Java:
  --CLASSPATH                 This switch lacks documentation
  --bootclasspath             This switch lacks documentation
  --classpath                 This switch lacks documentation
  --encoding                  This switch lacks documentation
  --extdirs                   This switch lacks documentation
  --output-class-directory    This switch lacks documentation
  --output-class-directory=   This switch lacks documentation
  --resource                  This switch lacks documentation
  --resource=                 This switch lacks documentation
  -CLASSPATH                  This switch lacks documentation
  -MD_                        This switch lacks documentation
  -MMD_                       This switch lacks documentation
  -Wall-deprecation           This switch lacks documentation
  -Wall-javadoc               This switch lacks documentation
  -Wassert-identifier         This switch lacks documentation
  -Wboxing                    This switch lacks documentation
  -Wchar-concat               This switch lacks documentation
  -Wcondition-assign          This switch lacks documentation
  -Wconstructor-name          This switch lacks documentation
  -Wdep-ann                   This switch lacks documentation
  -Wdiscouraged               This switch lacks documentation
  -Wempty-block               This switch lacks documentation
  -Wenum-identifier           This switch lacks documentation
  -Wenum-switch               This switch lacks documentation
  -Wextraneous-semicolon      Warn if deprecated empty statements are found
  -Wfallthrough               This switch lacks documentation
  -Wfield-hiding              This switch lacks documentation
  -Wfinal-bound               This switch lacks documentation
  -Wfinally                   This switch lacks documentation
  -Wforbidden                 This switch lacks documentation
  -Whiding                    This switch lacks documentation
  -Windirect-static           This switch lacks documentation
  -Wintf-annotation           This switch lacks documentation
  -Wintf-non-inherited        This switch lacks documentation
  -Wjavadoc                   This switch lacks documentation
  -Wlocal-hiding              This switch lacks documentation
  -Wmasked-catch-block        This switch lacks documentation
  -Wnls                       This switch lacks documentation
  -Wno-effect-assign          This switch lacks documentation
  -Wnull                      This switch lacks documentation
  -Wout-of-date               Warn if .class files are out of date
  -Wover-ann                  This switch lacks documentation
  -Wparam-assign              This switch lacks documentation
  -Wpkg-default-method        This switch lacks documentation
  -Wraw                       This switch lacks documentation
  -Wredundant-modifiers       Warn if modifiers are specified when not necessary
  -Wserial                    This switch lacks documentation
  -Wspecial-param-hiding      This switch lacks documentation
  -Wstatic-access             This switch lacks documentation
  -Wstatic-receiver           This switch lacks documentation
  -Wsuppress                  This switch lacks documentation
  -Wsynthetic-access          This switch lacks documentation
  -Wtasks                     This switch lacks documentation
  -Wtype-hiding               This switch lacks documentation
  -Wuncheck                   This switch lacks documentation
  -Wunnecessary-else          This switch lacks documentation
  -Wunqualified-field         This switch lacks documentation
  -Wunused-argument           This switch lacks documentation
  -Wunused-import             This switch lacks documentation
  -Wunused-label              Warn when a label is unused
  -Wunused-local              This switch lacks documentation
  -Wunused-private            This switch lacks documentation
  -Wunused-thrown             This switch lacks documentation
  -Wuseless-type-check        This switch lacks documentation
  -Wvarargs-cast              This switch lacks documentation
  -Wwarning-token             This switch lacks documentation
  -bootclasspath              This switch lacks documentation
  -classpath                  This switch lacks documentation
  -encoding                   This switch lacks documentation
  --CLASSPATH                 Deprecated; use --classpath instead
  -fassert                    Permit the use of the assert keyword
  -fassume-compiled           This switch lacks documentation
  -fassume-compiled=          This switch lacks documentation
  -faux-classpath             This switch lacks documentation
  --bootclasspath=<path>      Replace system path
  -fbootstrap-classes         Generated should be loaded by bootstrap loader
  -fcheck-references          Generate checks for references to NULL
  --classpath=<path>          Set class path
  -fcompile-resource=         This switch lacks documentation
  -fdisable-assertions        This switch lacks documentation
  -fdisable-assertions=       This switch lacks documentation
  -femit-class-file           Output a class file
  -femit-class-files          Alias for -femit-class-file
  -fenable-assertions         This switch lacks documentation
  -fenable-assertions=        This switch lacks documentation
  --encoding=<encoding>       Choose input encoding (defaults from your locale)
  --extdirs=<path>            Set the extension directory path
  -ffilelist-file             Input file is a file with a list of filenames to
                              compile
  -fforce-classes-archive-check Always check for non gcj generated classes
                              archives
  -fhash-synchronization      Assume the runtime uses a hash table to map an
                              object to its synchronization structure
  -findirect-classes          Generate instances of Class at runtime
  -findirect-dispatch         Use offset tables for virtual method calls
  -finline-functions          Integrate functions not declared "inline" into
                              their callers when profitable
  -fjni                       Assume native functions are implemented using JNI
  -foptimize-static-class-initialization Enable optimization of static class
                              initialization code
  -foutput-class-dir=         This switch lacks documentation
  -freduced-reflection        Reduce the amount of reflection meta-data
                              generated
  -fsaw-java-file             This switch lacks documentation
  -fsource-filename=          This switch lacks documentation
  -fsource=                   Set the source language version
  -fstore-check               Enable assignability checks for stores into
                              object arrays
  -ftarget=                   Set the target VM version
  -fuse-atomic-builtins       Generate code for built-in atomic operations
  -fuse-boehm-gc              Generate code for the Boehm GC
  -fuse-divide-subroutine     Call a library routine to do integer divisions
  -version                    Display the compiler's version

The following options are specific to just the language LTO:
  -fltrans                    Run the link-time optimizer in local
                              transformation (LTRANS) mode.
  -fltrans-output-list=       Specify a file to which a list of files output by
                              LTRANS is written.
  -fresolution=               The resolution file
  -fwpa                       Run the link-time optimizer in whole program
                              analysis (WPA) mode.

The following options are specific to just the language ObjC:
 None found.  Use --help=ObjC to show *all* the options supported by the ObjC front-end

The following options are specific to just the language ObjC++:
  -fobjc-call-cxx-cdtors      Generate special Objective-C methods to
                              initialize/destroy non-POD C++ ivars, if needed

The following options are language-related:
  --all-warnings              This switch lacks documentation
  --ansi                      This switch lacks documentation
  --assert                    This switch lacks documentation
  --assert=                   This switch lacks documentation
  --comments                  This switch lacks documentation
  --comments-in-macros        This switch lacks documentation
  --define-macro              This switch lacks documentation
  --define-macro=             This switch lacks documentation
  --dependencies              This switch lacks documentation
  --dump                      This switch lacks documentation
  --dump=                     This switch lacks documentation
  --imacros                   This switch lacks documentation
  --imacros=                  This switch lacks documentation
  --include                   This switch lacks documentation
  --include-barrier           This switch lacks documentation
  --include-directory         This switch lacks documentation
  --include-directory-after   This switch lacks documentation
  --include-directory-after=  This switch lacks documentation
  --include-directory=        This switch lacks documentation
  --include-prefix            This switch lacks documentation
  --include-prefix=           This switch lacks documentation
  --include-with-prefix       This switch lacks documentation
  --include-with-prefix-after This switch lacks documentation
  --include-with-prefix-after= This switch lacks documentation
  --include-with-prefix-before This switch lacks documentation
  --include-with-prefix-before= This switch lacks documentation
  --include-with-prefix=      This switch lacks documentation
  --include=                  This switch lacks documentation
  --no-line-commands          This switch lacks documentation
  --no-standard-includes      This switch lacks documentation
  --no-standard-libraries     This switch lacks documentation
  --no-warnings               This switch lacks documentation
  --output                    This switch lacks documentation
  --output-pch=               This switch lacks documentation
  --output=                   This switch lacks documentation
  --pedantic                  This switch lacks documentation
  --preprocess                This switch lacks documentation
  --print-missing-file-dependencies This switch lacks documentation
  --trace-includes            This switch lacks documentation
  --traditional-cpp           This switch lacks documentation
  --trigraphs                 This switch lacks documentation
  --undefine-macro            This switch lacks documentation
  --undefine-macro=           This switch lacks documentation
  --user-dependencies         This switch lacks documentation
  --verbose                   This switch lacks documentation
  --write-dependencies        This switch lacks documentation
  --write-user-dependencies   This switch lacks documentation
  -A<question>=<answer>       Assert the <answer> to <question>.  Putting '-'
                              before <question> disables the <answer> to
                              <question>
  -C                          Do not discard comments
  -CC                         Do not discard comments in macro expansions
  -D<macro>[=<val>]           Define a <macro> with <val> as its value.  If
                              just <macro> is given, <val> is taken to be 1
  -E                          This switch lacks documentation
  -F <dir>                    Add <dir> to the end of the main framework
                              include path
  -H                          Print the name of header files as they are used
  -I <dir>                    Add <dir> to the end of the main include path
  -M                          Generate make dependencies
  -MD                         Generate make dependencies and compile
  -MF <file>                  Write dependency output to the given file
  -MG                         Treat missing header files as generated files
  -MM                         Like -M but ignore system header files
  -MMD                        Like -MD but ignore system header files
  -MP                         Generate phony targets for all headers
  -MQ <target>                Add a MAKE-quoted target
  -MT <target>                Add an unquoted target
  -P                          Do not generate #line directives
  -U<macro>                   Undefine <macro>
  -Wabi                       Warn about things that will change when compiling
                              with an ABI-compliant compiler
  -Wabi-tag                   Warn if a subobject has an abi_tag attribute that
                              the complete object type does not have
  -Waddress                   Warn about suspicious uses of memory addresses
  -Wall                       Enable most warning messages
  -Wassign-intercept          Warn whenever an Objective-C assignment is being
                              intercepted by the garbage collector
  -Wbad-function-cast         Warn about casting functions to incompatible types
  -Wbuiltin-macro-redefined   Warn when a built-in preprocessor macro is
                              undefined or redefined
  -Wc++-compat                Warn about C constructs that are not in the
                              common subset of C and C++
  -Wc++0x-compat              Deprecated in favor of -Wc++11-compat
  -Wc++11-compat              Warn about C++ constructs whose meaning differs
                              between ISO C++ 1998 and ISO C++ 2011
  -Wcast-qual                 Warn about casts which discard qualifiers
  -Wchar-subscripts           Warn about subscripts whose type is "char"
  -Wclobbered                 Warn about variables that might be changed by
                              "longjmp" or "vfork"
  -Wcomment                   Warn about possibly nested block comments, and
                              C++ comments spanning more than one physical line
  -Wcomments                  Synonym for -Wcomment
  -Wconversion                Warn for implicit type conversions that may
                              change a value
  -Wconversion-null           Warn for converting NULL from/to a non-pointer
                              type
  -Wctor-dtor-privacy         Warn when all constructors and destructors are
                              private
  -Wdeclaration-after-statement Warn when a declaration is found after a
                              statement
  -Wdelete-non-virtual-dtor   Warn about deleting polymorphic objects with non-
                              virtual destructors
  -Wdeprecated                Warn if a deprecated compiler feature, class,
                              method, or field is used
  -Wdiv-by-zero               Warn about compile-time integer division by zero
  -Wdouble-promotion          Warn about implicit conversions from "float" to
                              "double"
  -Weffc++                    Warn about violations of Effective C++ style rules
  -Wempty-body                Warn about an empty body in an if or else
                              statement
  -Wendif-labels              Warn about stray tokens after #elif and #endif
  -Wenum-compare              Warn about comparison of different enum types
  -Werror                     Treat all warnings as errors
  -Werror-implicit-function-declaration This switch is deprecated; use
                              -Werror=implicit-function-declaration instead
  -Wfloat-equal               Warn if testing floating point numbers for
                              equality
  -Wformat                    Warn about printf/scanf/strftime/strfmon format
                              string anomalies
  -Wformat-contains-nul       Warn about format strings that contain NUL bytes
  -Wformat-extra-args         Warn if passing too many arguments to a function
                              for its format string
  -Wformat-nonliteral         Warn about format strings that are not literals
  -Wformat-security           Warn about possible security problems with format
                              functions
  -Wformat-y2k                Warn about strftime formats yielding 2-digit years
  -Wformat-zero-length        Warn about zero-length formats
  -Wformat=                   Warn about printf/scanf/strftime/strfmon format
                              string anomalies
  -Wignored-qualifiers        Warn whenever type qualifiers are ignored.
  -Wimplicit                  Warn about implicit declarations
  -Wimplicit-function-declaration Warn about implicit function declarations
  -Wimplicit-int              Warn when a declaration does not specify a type
  -Wimport                    This switch lacks documentation
  -Winherited-variadic-ctor   Warn about C++11 inheriting constructors when the
                              base has a variadic constructor
  -Winit-self                 Warn about variables which are initialized to
                              themselves
  -Wint-to-pointer-cast       Warn when there is a cast to a pointer from an
                              integer of a different size
  -Winvalid-offsetof          Warn about invalid uses of the "offsetof" macro
  -Winvalid-pch               Warn about PCH files that are found but not used
  -Wjump-misses-init          Warn when a jump misses a variable initialization
  -Wliteral-suffix            Warn when a string or character literal is
                              followed by a ud-suffix which does not begin with
                              an underscore.
  -Wlogical-op                Warn when a logical operator is suspiciously
                              always evaluating to true or false
  -Wlong-long                 Do not warn about using "long long" when -pedantic
  -Wmain                      Warn about suspicious declarations of "main"
  -Wmaybe-uninitialized       Warn about maybe uninitialized automatic variables
  -Wmissing-braces            Warn about possibly missing braces around
                              initializers
  -Wmissing-declarations      Warn about global functions without previous
                              declarations
  -Wmissing-field-initializers Warn about missing fields in struct initializers
  -Wmissing-format-attribute  This switch lacks documentation
  -Wmissing-include-dirs      Warn about user-specified include directories
                              that do not exist
  -Wmissing-parameter-type    Warn about function parameters declared without a
                              type specifier in K&R-style functions
  -Wmissing-prototypes        Warn about global functions without prototypes
  -Wmudflap                   Warn about constructs not instrumented by
                              -fmudflap
  -Wmultichar                 Warn about use of multi-character character
                              constants
  -Wnarrowing                 Warn about narrowing conversions within { } that
                              are ill-formed in C++11
  -Wnested-externs            Warn about "extern" declarations not at file scope
  -Wnoexcept                  Warn when a noexcept expression evaluates to
                              false even though the expression can't actually
                              throw
  -Wnon-template-friend       Warn when non-templatized friend functions are
                              declared within a template
  -Wnon-virtual-dtor          Warn about non-virtual destructors
  -Wnonnull                   Warn about NULL being passed to argument slots
                              marked as requiring non-NULL
  -Wnormalized=<id|nfc|nfkc>  Warn about non-normalised Unicode strings
  -Wold-style-cast            Warn if a C-style cast is used in a program
  -Wold-style-declaration     Warn for obsolescent usage in a declaration
  -Wold-style-definition      Warn if an old-style parameter definition is used
  -Woverlength-strings        Warn if a string is longer than the maximum
                              portable length specified by the standard
  -Woverloaded-virtual        Warn about overloaded virtual function names
  -Woverride-init             Warn about overriding initializers without side
                              effects
  -Wpacked-bitfield-compat    Warn about packed bit-fields whose offset changed
                              in GCC 4.4
  -Wparentheses               Warn about possibly missing parentheses
  -Wpedantic                  Issue warnings needed for strict compliance to
                              the standard
  -Wpedantic-ms-format        Warn about none ISO msvcrt scanf/printf width
                              extensions
  -Wpmf-conversions           Warn when converting the type of pointers to
                              member functions
  -Wpointer-arith             Warn about function pointer arithmetic
  -Wpointer-sign              Warn when a pointer differs in signedness in an
                              assignment
  -Wpointer-to-int-cast       Warn when a pointer is cast to an integer of a
                              different size
  -Wpragmas                   Warn about misuses of pragmas
  -Wproperty-assign-default   Warn if a property for an Objective-C object has
                              no assign semantics specified
  -Wprotocol                  Warn if inherited methods are unimplemented
  -Wpsabi                     This switch lacks documentation
  -Wredundant-decls           Warn about multiple declarations of the same
                              object
  -Wreorder                   Warn when the compiler reorders code
  -Wreturn-local-addr         Warn about returning a pointer/reference to a
                              local or temporary variable.
  -Wreturn-type               Warn whenever a function's return type defaults
                              to "int" (C), or about inconsistent return types
                              (C++)
  -Wselector                  Warn if a selector has multiple methods
  -Wsequence-point            Warn about possible violations of sequence point
                              rules
  -Wsign-compare              Warn about signed-unsigned comparisons
  -Wsign-conversion           Warn for implicit type conversions between signed
                              and unsigned integers
  -Wsign-promo                Warn when overload promotes from unsigned to
                              signed
  -Wsizeof-pointer-memaccess  This switch lacks documentation
  -Wstrict-aliasing=          Warn about code which might break strict aliasing
                              rules
  -Wstrict-null-sentinel      Warn about uncasted NULL used as sentinel
  -Wstrict-overflow=          Warn about optimizations that assume that signed
                              overflow is undefined
  -Wstrict-prototypes         Warn about unprototyped function declarations
  -Wstrict-selector-match     Warn if type signatures of candidate methods do
                              not match exactly
  -Wsuggest-attribute=format  Warn about functions which might be candidates
                              for format attributes
  -Wswitch                    Warn about enumerated switches, with no default,
                              missing a case
  -Wswitch-default            Warn about enumerated switches missing a
                              "default:" statement
  -Wswitch-enum               Warn about all enumerated switches missing a
                              specific case
  -Wsync-nand                 Warn when __sync_fetch_and_nand and
                              __sync_nand_and_fetch built-in functions are used
  -Wsynth                     Deprecated.  This switch has no effect
  -Wsystem-headers            Do not suppress warnings from system headers
  -Wtraditional               Warn about features not present in traditional C
  -Wtraditional-conversion    Warn of prototypes causing type conversions
                              different from what would happen in the absence
                              of prototype
  -Wtrigraphs                 Warn if trigraphs are encountered that might
                              affect the meaning of the program
  -Wundeclared-selector       Warn about @selector()s without previously
                              declared methods
  -Wundef                     Warn if an undefined macro is used in an #if
                              directive
  -Wuninitialized             Warn about uninitialized automatic variables
  -Wunknown-pragmas           Warn about unrecognized pragmas
  -Wunsuffixed-float-constants Warn about unsuffixed float constants
  -Wunused                    Enable all -Wunused- warnings
  -Wunused-local-typedefs     Warn when typedefs locally defined in a function
                              are not used
  -Wunused-macros             Warn about macros defined in the main file that
                              are not used
  -Wunused-result             Warn if a caller of a function, marked with
                              attribute warn_unused_result, does not use its
                              return value
  -Wuseless-cast              Warn about useless casts
  -Wvarargs                   Warn about questionable usage of the macros used
                              to retrieve variable arguments
  -Wvariadic-macros           Warn about using variadic macros
  -Wvirtual-move-assign       Warn if a virtual base has a non-trivial move
                              assignment operator
  -Wvla                       Warn if a variable length array is used
  -Wvolatile-register-var     Warn when a register variable is declared volatile
  -Wwrite-strings             In C++, nonzero means warn about deprecated
                              conversion from string literals to 'char *'.  In
                              C, similar warning, except that the conversion is
                              of course not deprecated by the ISO C standard.
  -Wzero-as-null-pointer-constant Warn when a literal '0' is used as null
                              pointer
  -ansi                       A synonym for -std=c89 (for C) or -std=c++98 (for
                              C++)
  -d<letters>                 Enable dumps from specific passes of the compiler
  -fRTS=                      Select the runtime
  -faccess-control            Enforce class member access control semantics
  -fada-spec-parent=          -fada-spec-parent=unit  Dump Ada specs as child
                              units of given parent
  -fall-virtual               This switch lacks documentation
  -fallow-parameterless-variadic-functions Allow variadic functions without
                              named parameter
  -falt-external-templates    No longer supported
  -fasm                       Recognize the "asm" keyword
  -fbuilding-libgcc           This switch lacks documentation
  -fbuiltin                   Recognize built-in functions
  -fbuiltin-                  This switch lacks documentation
  -fcanonical-system-headers  Where shorter, use canonicalized paths to systems
                              headers.
  -fcheck-new                 Check the return value of new
  -fcond-mismatch             Allow the arguments of the '?' operator to have
                              different types
  -fconserve-space            Does nothing.  Preserved for backward
                              compatibility.
  -fconst-string-class=<name> Use class <name> for constant strings
  -fconstexpr-depth=<number>  Specify maximum constexpr recursion depth
  -fdebug-cpp                 Emit debug annotations during preprocessing
  -fdeduce-init-list          enable deduction of std::initializer_list for a
                              template type parameter from a brace-enclosed
                              initializer-list
  -fdefault-inline            Does nothing.  Preserved for backward
                              compatibility.
  -fdirectives-only           Preprocess directives only.
  -fdollars-in-identifiers    Permit '$' as an identifier character
  -fdump-ada-spec             Write all declarations as Ada code transitively
  -fdump-ada-spec-slim        Write all declarations as Ada code for the given
                              file only
  -felide-constructors        This switch lacks documentation
  -femit-struct-debug-baseonly Aggressive reduced debug info for structs
  -femit-struct-debug-detailed=<spec-list> Detailed reduced debug info for
                              structs
  -femit-struct-debug-reduced Conservative reduced debug info for structs
  -fenforce-eh-specs          Generate code to check exception specifications
  -fenum-int-equiv            This switch lacks documentation
  -fexec-charset=<cset>       Convert all strings and character constants to
                              character set <cset>
  -fext-numeric-literals      Interpret imaginary, fixed-point, or other gnu
                              number suffix as the corresponding number literal
                              rather than a user-defined number literal.
  -fextended-identifiers      Permit universal character names (\u and \U) in
                              identifiers
  -fextern-tls-init           Support dynamic initialization of thread-local
                              variables in a different translation unit
  -fexternal-templates        This switch lacks documentation
  -ffor-scope                 Scope of for-init-statement variables is local to
                              the loop
  -ffreestanding              Do not assume that standard C libraries and
                              "main" exist
  -ffriend-injection          Inject friend functions into enclosing namespace
  -fgnu-keywords              Recognize GNU-defined keywords
  -fgnu-runtime               Generate code for GNU runtime environment
  -fgnu89-inline              Use traditional GNU semantics for inline functions
  -fguiding-decls             This switch lacks documentation
  -fhandle-exceptions         This switch lacks documentation
  -fhonor-std                 This switch lacks documentation
  -fhosted                    Assume normal C execution environment
  -fhuge-objects              No longer supported
  -fimplement-inlines         Export functions even if they can be inlined
  -fimplicit-inline-templates Emit implicit instantiations of inline templates
  -fimplicit-templates        Emit implicit instantiations of templates
  -finput-charset=<cset>      Specify the default character set for source files
  -fkeep-inline-dllexport     Don't emit dllexported inline functions unless
                              needed
  -flabels-ok                 This switch lacks documentation
  -flax-vector-conversions    Allow implicit conversions between vectors with
                              differing numbers of subparts and/or differing
                              element types.
  -fms-extensions             Don't warn about uses of Microsoft extensions
  -fmudflap                   Add mudflap bounds-checking instrumentation for
                              single-threaded program
  -fmudflapir                 Ignore read operations when inserting mudflap
                              instrumentation
  -fmudflapth                 Add mudflap bounds-checking instrumentation for
                              multi-threaded program
  -fname-mangling-version-    This switch lacks documentation
  -fnew-abi                   This switch lacks documentation
  -fnext-runtime              Generate code for NeXT (Apple Mac OS X) runtime
                              environment
  -fnil-receivers             Assume that receivers of Objective-C messages may
                              be nil
  -fnonansi-builtins          This switch lacks documentation
  -fnonnull-objects           This switch lacks documentation
  -fnothrow-opt               Treat a throw() exception specification as
                              noexcept to improve code size
  -fobjc-abi-version=         Specify which ABI to use for Objective-C family
                              code and meta-data generation.
  -fobjc-direct-dispatch      Allow fast jumps to the message dispatcher
  -fobjc-exceptions           Enable Objective-C exception and synchronization
                              syntax
  -fobjc-gc                   Enable garbage collection (GC) in Objective-C/
                              Objective-C++ programs
  -fobjc-nilcheck             Enable inline checks for nil receivers with the
                              NeXT runtime and ABI version 2.
  -fobjc-sjlj-exceptions      Enable Objective-C setjmp exception handling
                              runtime
  -fobjc-std=objc1            Conform to the Objective-C 1.0 language as
                              implemented in GCC 4.0
  -fopenmp                    Enable OpenMP (implies -frecursive in Fortran)
  -foperator-names            Recognize C++ keywords like "compl" and "xor"
  -foptional-diags            Does nothing.  Preserved for backward
                              compatibility.
  -fpch-deps                  This switch lacks documentation
  -fpch-preprocess            Look for and use PCH files even when preprocessing
  -fpermissive                Downgrade conformance errors to warnings
  -fplan9-extensions          Enable Plan 9 language extensions
  -fpreprocessed              Treat the input file as already preprocessed
  -fpretty-templates          -fno-pretty-templates Do not pretty-print
                              template specializations as the template
                              signature followed by the arguments
  -freplace-objc-classes      Used in Fix-and-Continue mode to indicate that
                              object files may be swapped in at runtime
  -frepo                      Enable automatic template instantiation
  -frtti                      Generate run time type descriptor information
  -fshort-double              Use the same size for double as for float
  -fshort-enums               Use the narrowest integer type possible for
                              enumeration types
  -fshort-wchar               Force the underlying type for "wchar_t" to be
                              "unsigned short"
  -fsigned-bitfields          When "signed" or "unsigned" is not given make the
                              bitfield signed
  -fsigned-char               Make "char" signed by default
  -fsquangle                  This switch lacks documentation
  -fstats                     Display statistics accumulated during compilation
  -fstrict-enums              Assume that values of enumeration type are always
                              within the minimum range of that type
  -fstrict-prototype          This switch lacks documentation
  -ftabstop=<number>          Distance between tab stops for column reporting
  -ftemplate-backtrace-limit= Set the maximum number of template instantiation
                              notes for a single warning or error
  -ftemplate-depth-           This switch lacks documentation
  -ftemplate-depth=<number>   Specify maximum template instantiation depth
  -fthis-is-variable          This switch lacks documentation
  -fno-threadsafe-statics     Do not generate thread-safe code for initializing
                              local statics
  -ftrack-macro-expansion     This switch lacks documentation
  -ftrack-macro-expansion=    -ftrack-macro-expansion=<0|1|2>  Track locations
                              of tokens coming from macro expansion and display
                              them in error messages
  -funsigned-bitfields        When "signed" or "unsigned" is not given make the
                              bitfield unsigned
  -funsigned-char             Make "char" unsigned by default
  -fuse-cxa-atexit            Use __cxa_atexit to register destructors
  -fuse-cxa-get-exception-ptr Use __cxa_get_exception_ptr in exception handling
  -fvisibility-inlines-hidden Marks all inlined functions and methods as having
                              hidden visibility
  -fvisibility-ms-compat      Changes visibility to match Microsoft Visual
                              Studio by default
  -fvtable-gc                 No longer supported
  -fvtable-thunks             No longer supported
  -fweak                      Emit common-like symbols as weak symbols
  -fwide-exec-charset=<cset>  Convert all wide strings and character constants
                              to character set <cset>
  -fworking-directory         Generate a #line directive pointing at the
                              current working directory
  -fxref                      No longer supported
  -fzero-link                 Generate lazy class lookup (via objc_getClass())
                              for use in Zero-Link mode
  -gant                       Catch typos
  -gen-decls                  Dump declarations to a .decl file
  -gnat<options>              Specify options to GNAT
  -gnatO                      Set name of output ALI file (internal switch)
  -idirafter <dir>            Add <dir> to the end of the system include path
  -imacros <file>             Accept definition of macros in <file>
  -imultilib <dir>            Set <dir> to be the multilib include subdirectory
  -include <file>             Include the contents of <file> before other files
  -iprefix <path>             Specify <path> as a prefix for next two options
  -iquote <dir>               Add <dir> to the end of the quote include path
  -isysroot <dir>             Set <dir> to be the system root directory
  -isystem <dir>              Add <dir> to the start of the system include path
  -iwithprefix <dir>          Add <dir> to the end of the system include path
  -iwithprefixbefore <dir>    Add <dir> to the end of the main include path
  -nostdinc                   Do not search standard system include directories
                              (those specified with -isystem will still be used)
  -nostdinc++                 Do not search standard system include directories
                              for C++
  -nostdlib                   Do not look for object files in standard path
  -o <file>                   Place output into <file>
  -pedantic                   This switch lacks documentation
  -print-objc-runtime-info    Generate C header of platform-specific features
  -remap                      Remap file names when including files
  -std=c++03                  Conform to the ISO 1998 C++ standard revised by
                              the 2003 technical corrigendum
  -std=c++0x                  Deprecated in favor of -std=c++11
  -std=c++11                  Conform to the ISO 2011 C++ standard
                              (experimental and incomplete support)
  -std=c++1y                  Conform to the ISO 201y(7?) C++ draft standard
                              (experimental and incomplete support)
  -std=c++98                  Conform to the ISO 1998 C++ standard revised by
                              the 2003 technical corrigendum
  -std=c11                    Conform to the ISO 2011 C standard (experimental
                              and incomplete support)
  -std=c1x                    Deprecated in favor of -std=c11
  -std=c89                    Conform to the ISO 1990 C standard
  -std=c90                    Conform to the ISO 1990 C standard
  -std=c99                    Conform to the ISO 1999 C standard
  -std=c9x                    Deprecated in favor of -std=c99
  -std=gnu++03                Conform to the ISO 1998 C++ standard revised by
                              the 2003 technical corrigendum with GNU extensions
  -std=gnu++0x                Deprecated in favor of -std=gnu++11
  -std=gnu++11                Conform to the ISO 2011 C++ standard with GNU
                              extensions (experimental and incomplete support)
  -std=gnu++1y                Conform to the ISO 201y(7?) C++ draft standard
                              with GNU extensions (experimental and incomplete
                              support)
  -std=gnu++98                Conform to the ISO 1998 C++ standard revised by
                              the 2003 technical corrigendum with GNU extensions
  -std=gnu11                  Conform to the ISO 2011 C standard with GNU
                              extensions (experimental and incomplete support)
  -std=gnu1x                  Deprecated in favor of -std=gnu11
  -std=gnu89                  Conform to the ISO 1990 C standard with GNU
                              extensions
  -std=gnu90                  Conform to the ISO 1990 C standard with GNU
                              extensions
  -std=gnu99                  Conform to the ISO 1999 C standard with GNU
                              extensions
  -std=gnu9x                  Deprecated in favor of -std=gnu99
  -std=iso9899:1990           Conform to the ISO 1990 C standard
  -std=iso9899:199409         Conform to the ISO 1990 C standard as amended in
                              1994
  -std=iso9899:1999           Conform to the ISO 1999 C standard
  -std=iso9899:199x           Deprecated in favor of -std=iso9899:1999
  -std=iso9899:2011           Conform to the ISO 2011 C standard (experimental
                              and incomplete support)
  -traditional-cpp            Enable traditional preprocessing
  -trigraphs                  Support ISO C trigraphs
  -undef                      Do not predefine system-specific and GCC-specific
                              macros
  -v                          Enable verbose output
  -w                          Suppress warnings

The --param option recognizes the following as parameters:
  predictable-branch-outcome  Maximal estimated outcome of branch considered
                              predictable
  inline-min-speedup          The minimal estimated speedup allowing inliner to
                              ignore inline-insns-single and inline-isnsns-auto
  max-inline-insns-single     The maximum number of instructions in a single
                              function eligible for inlining
  max-inline-insns-auto       The maximum number of instructions when
                              automatically inlining
  max-inline-insns-recursive  The maximum number of instructions inline
                              function can grow to via recursive inlining
  max-inline-insns-recursive-auto The maximum number of instructions non-inline
                              function can grow to via recursive inlining
  max-inline-recursive-depth  The maximum depth of recursive inlining for
                              inline functions
  max-inline-recursive-depth-auto The maximum depth of recursive inlining for
                              non-inline functions
  min-inline-recursive-probability Inline recursively only when the probability
                              of call being executed exceeds the parameter
  max-early-inliner-iterations The maximum number of nested indirect inlining
                              performed by early inliner
  comdat-sharing-probability  Probability that COMDAT function will be shared
                              with different compilation unit
  partial-inlining-entry-probability Maximum probability of the entry BB of
                              split region (in percent relative to entry BB of
                              the function) to make partial inlining happen
  max-variable-expansions-in-unroller If -fvariable-expansion-in-unroller is
                              used, the maximum number of times that an
                              individual variable will be expanded during loop
                              unrolling
  min-vect-loop-bound         If -ftree-vectorize is used, the minimal loop
                              bound of a loop to be considered for vectorization
  max-delay-slot-insn-search  The maximum number of instructions to consider to
                              fill a delay slot
  max-delay-slot-live-search  The maximum number of instructions to consider to
                              find accurate live register information
  max-pending-list-length     The maximum length of scheduling's pending
                              operations list
  max-modulo-backtrack-attempts The maximum number of backtrack attempts the
                              scheduler should make when modulo scheduling a
                              loop
  large-function-insns        The size of function body to be considered large
  large-function-growth       Maximal growth due to inlining of large function
                              (in percent)
  large-unit-insns            The size of translation unit to be considered
                              large
  inline-unit-growth          How much can given compilation unit grow because
                              of the inlining (in percent)
  ipcp-unit-growth            How much can given compilation unit grow because
                              of the interprocedural constant propagation (in
                              percent)
  early-inlining-insns        Maximal estimated growth of function body caused
                              by early inlining of single call
  large-stack-frame           The size of stack frame to be considered large
  large-stack-frame-growth    Maximal stack frame growth due to inlining (in
                              percent)
  max-gcse-memory             The maximum amount of memory to be allocated by
                              GCSE
  max-gcse-insertion-ratio    The maximum ratio of insertions to deletions of
                              expressions in GCSE
  gcse-after-reload-partial-fraction The threshold ratio for performing partial
                              redundancy elimination after reload
  gcse-after-reload-critical-fraction The threshold ratio of critical edges
                              execution count that permit performing redundancy
                              elimination after reload
  gcse-cost-distance-ratio    Scaling factor in calculation of maximum distance
                              an expression can be moved by GCSE optimizations
  gcse-unrestricted-cost      Cost at which GCSE optimizations will not
                              constraint the distance an expression can travel
  max-hoist-depth             Maximum depth of search in the dominator tree for
                              expressions to hoist
  max-unrolled-insns          The maximum number of instructions to consider to
                              unroll in a loop
  max-average-unrolled-insns  The maximum number of instructions to consider to
                              unroll in a loop on average
  max-unroll-times            The maximum number of unrollings of a single loop
  max-peeled-insns            The maximum number of insns of a peeled loop
  max-peel-times              The maximum number of peelings of a single loop
  max-peel-branches           The maximum number of branches on the path
                              through the peeled sequence
  max-completely-peeled-insns The maximum number of insns of a completely
                              peeled loop
  max-completely-peel-times   The maximum number of peelings of a single loop
                              that is peeled completely
  max-once-peeled-insns       The maximum number of insns of a peeled loop that
                              rolls only once
  max-completely-peel-loop-nest-depth The maximum depth of a loop nest we
                              completely peel
  max-unswitch-insns          The maximum number of insns of an unswitched loop
  max-unswitch-level          The maximum number of unswitchings in a single
                              loop
  max-iterations-to-track     Bound on the number of iterations the brute force
                              # of iterations analysis algorithm evaluates
  max-iterations-computation-cost Bound on the cost of an expression to compute
                              the number of iterations
  sms-max-ii-factor           A factor for tuning the upper bound that swing
                              modulo scheduler uses for scheduling a loop
  sms-min-sc                  The minimum value of stage count that swing
                              modulo scheduler will generate.
  sms-dfa-history             The number of cycles the swing modulo scheduler
                              considers when checking conflicts using DFA
  sms-loop-average-count-threshold A threshold on the average loop count
                              considered by the swing modulo scheduler
  hot-bb-count-ws-permille    A basic block profile count is considered hot if
                              it contributes to the given permillage of the
                              entire profiled execution
  hot-bb-frequency-fraction   Select fraction of the maximal frequency of
                              executions of basic block in function given basic
                              block needs to have to be considered hot
  align-threshold             Select fraction of the maximal frequency of
                              executions of basic block in function given basic
                              block get alignment
  align-loop-iterations       Loops iterating at least selected number of
                              iterations will get loop alignement.
  max-predicted-iterations    The maximum number of loop iterations we predict
                              statically
  tracer-dynamic-coverage-feedback The percentage of function, weighted by
                              execution frequency, that must be covered by
                              trace formation. Used when profile feedback is
                              available
  tracer-dynamic-coverage     The percentage of function, weighted by execution
                              frequency, that must be covered by trace
                              formation. Used when profile feedback is not
                              available
  tracer-max-code-growth      Maximal code growth caused by tail duplication
                              (in percent)
  tracer-min-branch-ratio     Stop reverse growth if the reverse probability of
                              best edge is less than this threshold (in percent)
  tracer-min-branch-probability-feedback Stop forward growth if the probability
                              of best edge is less than this threshold (in
                              percent). Used when profile feedback is available
  tracer-min-branch-probability Stop forward growth if the probability of best
                              edge is less than this threshold (in percent).
                              Used when profile feedback is not available
  max-crossjump-edges         The maximum number of incoming edges to consider
                              for crossjumping
  min-crossjump-insns         The minimum number of matching instructions to
                              consider for crossjumping
  max-grow-copy-bb-insns      The maximum expansion factor when copying basic
                              blocks
  max-goto-duplication-insns  The maximum number of insns to duplicate when
                              unfactoring computed gotos
  max-cse-path-length         The maximum length of path considered in cse
  max-cse-insns               The maximum instructions CSE process before
                              flushing
  lim-expensive               The minimum cost of an expensive expression in
                              the loop invariant motion
  iv-consider-all-candidates-bound Bound on number of candidates below that all
                              candidates are considered in iv optimizations
  iv-max-considered-uses      Bound on number of iv uses in loop optimized in
                              iv optimizations
  iv-always-prune-cand-set-bound If number of candidates in the set is smaller,
                              we always try to remove unused ivs during its
                              optimization
  scev-max-expr-size          Bound on size of expressions used in the scalar
                              evolutions analyzer
  scev-max-expr-complexity    Bound on the complexity of the expressions in the
                              scalar evolutions analyzer
  omega-max-vars              Bound on the number of variables in Omega
                              constraint systems
  omega-max-geqs              Bound on the number of inequalities in Omega
                              constraint systems
  omega-max-eqs               Bound on the number of equalities in Omega
                              constraint systems
  omega-max-wild-cards        Bound on the number of wild cards in Omega
                              constraint systems
  omega-hash-table-size       Bound on the size of the hash table in Omega
                              constraint systems
  omega-max-keys              Bound on the number of keys in Omega constraint
                              systems
  omega-eliminate-redundant-constraints When set to 1, use expensive methods to
                              eliminate all redundant constraints
  vect-max-version-for-alignment-checks Bound on number of runtime checks
                              inserted by the vectorizer's loop versioning for
                              alignment check
  vect-max-version-for-alias-checks Bound on number of runtime checks inserted
                              by the vectorizer's loop versioning for alias
                              check
  max-cselib-memory-locations The maximum memory locations recorded by cselib
  ggc-min-expand              Minimum heap expansion to trigger garbage
                              collection, as a percentage of the total size of
                              the heap
  ggc-min-heapsize            Minimum heap size before we start collecting
                              garbage, in kilobytes
  max-reload-search-insns     The maximum number of instructions to search
                              backward when looking for equivalent reload
  sink-frequency-threshold    Target block's relative execution frequency (as a
                              percentage) required to sink a statement
  max-sched-region-blocks     The maximum number of blocks in a region to be
                              considered for interblock scheduling
  max-sched-region-insns      The maximum number of insns in a region to be
                              considered for interblock scheduling
  max-pipeline-region-blocks  The maximum number of blocks in a region to be
                              considered for interblock scheduling
  max-pipeline-region-insns   The maximum number of insns in a region to be
                              considered for interblock scheduling
  min-spec-prob               The minimum probability of reaching a source
                              block for interblock speculative scheduling
  max-sched-extend-regions-iters The maximum number of iterations through CFG
                              to extend regions
  max-sched-insn-conflict-delay The maximum conflict delay for an insn to be
                              considered for speculative motion
  sched-spec-prob-cutoff      The minimal probability of speculation success
                              (in percents), so that speculative insn will be
                              scheduled.
  sched-state-edge-prob-cutoff The minimum probability an edge must have for
                              the scheduler to save its state across it.
  selsched-max-lookahead      The maximum size of the lookahead window of
                              selective scheduling
  selsched-max-sched-times    Maximum number of times that an insn could be
                              scheduled
  selsched-insns-to-rename    Maximum number of instructions in the ready list
                              that are considered eligible for renaming
  sched-mem-true-dep-cost     Minimal distance between possibly conflicting
                              store and load
  max-last-value-rtl          The maximum number of RTL nodes that can be
                              recorded as combiner's last value
  integer-share-limit         The upper bound for sharing integer constants
  ssp-buffer-size             The lower bound for a buffer to be considered for
                              stack smashing protection
  max-jump-thread-duplication-stmts Maximum number of statements allowed in a
                              block that needs to be duplicated when threading
                              jumps
  max-fields-for-field-sensitive Maximum number of fields in a structure before
                              pointer analysis treats the structure as a single
                              variable
  max-sched-ready-insns       The maximum number of instructions ready to be
                              issued to be considered by the scheduler during
                              the first scheduling pass
  max-dse-active-local-stores Maximum number of active local stores in RTL dead
                              store elimination
  prefetch-latency            The number of insns executed before prefetch is
                              completed
  simultaneous-prefetches     The number of prefetches that can run at the same
                              time
  l1-cache-size               The size of L1 cache
  l1-cache-line-size          The size of L1 cache line
  l2-cache-size               The size of L2 cache
  use-canonical-types         Whether to use canonical types
  max-partial-antic-length    Maximum length of partial antic set when
                              performing tree pre optimization
  sccvn-max-scc-size          Maximum size of a SCC before SCCVN stops
                              processing a function
  sccvn-max-alias-queries-per-access Maximum number of disambiguations to
                              perform per memory access
  ira-max-loops-num           Max loops number for regional RA
  ira-max-conflict-table-size Max size of conflict table in MB
  ira-loop-reserved-regs      The number of registers in each class kept unused
                              by loop invariant motion
  switch-conversion-max-branch-ratio The maximum ratio between array size and
                              switch branches for a switch conversion to take
                              place
  loop-block-tile-size        size of tiles for loop blocking
  graphite-max-nb-scop-params maximum number of parameters in a SCoP
  graphite-max-bbs-per-function maximum number of basic blocks per function to
                              be analyzed by Graphite
  loop-max-datarefs-for-datadeps Maximum number of datarefs in loop for
                              building loop data dependencies
  loop-invariant-max-bbs-in-loop Max basic blocks number in loop for loop
                              invariant motion
  slp-max-insns-in-bb         Maximum number of instructions in basic block to
                              be considered for SLP vectorization
  min-insn-to-prefetch-ratio  Min. ratio of insns to prefetches to enable
                              prefetching for a loop with an unknown trip count
  prefetch-min-insn-to-mem-ratio Min. ratio of insns to mem ops to enable
                              prefetching in a loop
  max-vartrack-size           Max. size of var tracking hash tables
  max-vartrack-expr-depth     Max. recursion depth for expanding var tracking
                              expressions
  max-vartrack-reverse-op-size Max. size of loc list for which reverse ops
                              should be added
  min-nondebug-insn-uid       The minimum UID to be used for a nondebug insn
  ipa-sra-ptr-growth-factor   Maximum allowed growth of size of new parameters
                              ipa-sra replaces a pointer to an aggregate with
  tm-max-aggregate-size       Size in bytes after which thread-local aggregates
                              should be instrumented with the logging functions
                              instead of save/restore pairs
  ipa-cp-value-list-size      Maximum size of a list of values associated with
                              each parameter for interprocedural constant
                              propagation
  ipa-cp-eval-threshold       Threshold ipa-cp opportunity evaluation that is
                              still considered beneficial to clone.
  ipa-max-agg-items           Maximum number of aggregate content items for a
                              parameter in jump functions and lattices
  ipa-cp-loop-hint-bonus      Compile-time bonus IPA-CP assigns to candidates
                              which make loop bounds or strides known.
  lto-partitions              Number of partitions the program should be split
                              to
  lto-min-partition           Minimal size of a partition for LTO (in estimated
                              instructions)
  cxx-max-namespaces-for-diagnostic-help Maximum number of namespaces to search
                              for alternatives when name lookup fails
  max-stores-to-sink          Maximum number of conditional store pairs that
                              can be sunk
  case-values-threshold       The smallest number of different values for which
                              it is best to use a jump-table instead of a tree
                              of conditional branches, if 0, use the default
                              for the machine
  allow-load-data-races       Allow new data races on loads to be introduced
  allow-store-data-races      Allow new data races on stores to be introduced
  allow-packed-load-data-races Allow new data races on packed data loads to be
                              introduced
  allow-packed-store-data-races Allow new data races on packed data stores to
                              be introduced
  tree-reassoc-width          Set the maximum number of instructions executed
                              in parallel in reassociated tree. If 0, use the
                              target dependent heuristic.
  max-tail-merge-comparisons  Maximum amount of similar bbs to compare a bb with
  max-tail-merge-iterations   Maximum amount of iterations of the pass over a
                              function
  max-tracked-strlens         Maximum number of strings for which strlen
                              optimization pass will track string lengths
  sched-pressure-algorithm    Which -fsched-pressure algorithm to apply
  max-slsr-cand-scan          Maximum length of candidate scans for straight-
                              line strength reduction

The following options control compiler warning messages:
  --extra-warnings            This switch lacks documentation
  -W                          This switch is deprecated; use -Wextra instead
  -Waggregate-return          Warn about returning structures, unions or arrays
  -Waggressive-loop-optimizations Warn if a loop with constant number of
                              iterations triggers undefined behavior
  -Warray-bounds              Warn if an array is accessed out of bounds
  -Wattributes                Warn about inappropriate attribute usage
  -Wcast-align                Warn about pointer casts which increase alignment
  -Wcoverage-mismatch         Warn in case profiles in -fprofile-use do not
                              match
  -Wcpp                       Warn when a #warning directive is encountered
  -Wdeprecated-declarations   Warn about uses of __attribute__((deprecated))
                              declarations
  -Wdisabled-optimization     Warn when an optimization pass is disabled
  -Wfree-nonheap-object       Warn when attempting to free a non-heap object
  -Winline                    Warn when an inlined function cannot be inlined
  -Winvalid-memory-model      Warn when an atomic memory model parameter is
                              known to be outside the valid range.
  -Wlarger-than-              This switch lacks documentation
  -Wlarger-than=<number>      Warn if an object is larger than <number> bytes
  -Woverflow                  Warn about overflow in arithmetic expressions
  -Wpacked                    Warn when the packed attribute has no effect on
                              struct layout
  -Wpadded                    Warn when padding is required to align structure
                              members
  -Wshadow                    Warn when one local variable shadows another
  -Wstack-protector           Warn when not issuing stack smashing protection
                              for some reason
  -Wstack-usage=              Warn if stack usage might be larger than
                              specified amount
  -Wstrict-aliasing           Warn about code which might break strict aliasing
                              rules
  -Wstrict-overflow           Warn about optimizations that assume that signed
                              overflow is undefined
  -Wsuggest-attribute=const   Warn about functions which might be candidates
                              for __attribute__((const))
  -Wsuggest-attribute=noreturn Warn about functions which might be candidates
                              for __attribute__((noreturn))
  -Wsuggest-attribute=pure    Warn about functions which might be candidates
                              for __attribute__((pure))
  -Wtrampolines               Warn whenever a trampoline is generated
  -Wtype-limits               Warn if a comparison is always true or always
                              false due to the limited range of the data type
  -Wunsafe-loop-optimizations Warn if the loop cannot be optimized due to
                              nontrivial assumptions.
  -Wunused-but-set-parameter  Warn when a function parameter is only set,
                              otherwise unused
  -Wunused-but-set-variable   Warn when a variable is only set, otherwise unused
  -Wunused-function           Warn when a function is unused
  -Wunused-parameter          Warn when a function parameter is unused
  -Wunused-value              Warn when an expression value is unused
  -Wunused-variable           Warn when a variable is unused
  -Wvector-operation-performance Warn when a vector operation is compiled
                              outside the SIMD

The following options control optimizations:
  -O<number>                  Set optimization level to <number>
  -Ofast                      Optimize for speed disregarding exact standards
                              compliance
  -Og                         Optimize for debugging experience rather than
                              speed or size
  -Os                         Optimize for space rather than speed
  -faggressive-loop-optimizations Aggressively optimize loops using language
                              constraints
  -falign-functions           Align the start of functions
  -falign-jumps               Align labels which are only reached by jumping
  -falign-labels              Align all labels
  -falign-loops               Align the start of loops
  -fasynchronous-unwind-tables Generate unwind tables that are exact at each
                              instruction boundary
  -fbranch-count-reg          Replace add, compare, branch with branch on count
                              register
  -fbranch-probabilities      Use profiling information for branch probabilities
  -fbranch-target-load-optimize Perform branch target load optimization before
                              prologue / epilogue threading
  -fbranch-target-load-optimize2 Perform branch target load optimization after
                              prologue / epilogue threading
  -fbtr-bb-exclusive          Restrict target load migration not to re-use
                              registers in any basic block
  -fcaller-saves              Save registers around function calls
  -fcombine-stack-adjustments Looks for opportunities to reduce stack
                              adjustments and stack references.
  -fcommon                    Do not put uninitialized globals in the common
                              section
  -fcompare-elim              Perform comparison elimination after register
                              allocation has finished
  -fconserve-stack            Do not perform optimizations increasing
                              noticeably stack usage
  -fcprop-registers           Perform a register copy-propagation optimization
                              pass
  -fcrossjumping              Perform cross-jumping optimization
  -fcse-follow-jumps          When running CSE, follow jumps to their targets
  -fcx-fortran-rules          Complex multiplication and division follow
                              Fortran rules
  -fcx-limited-range          Omit range reduction step when performing complex
                              division
  -fdata-sections             Place data items into their own section
  -fdce                       Use the RTL dead code elimination pass
  -fdefer-pop                 Defer popping functions args from stack until
                              later
  -fdelayed-branch            Attempt to fill delay slots of branch instructions
  -fdelete-null-pointer-checks Delete useless null pointer checks
  -fdevirtualize              Try to convert virtual calls to direct ones.
  -fdse                       Use the RTL dead store elimination pass
  -fearly-inlining            Perform early inlining
  -fexceptions                Enable exception handling
  -fexpensive-optimizations   Perform a number of minor, expensive optimizations
  -ffinite-math-only          Assume no NaNs or infinities are generated
  -ffloat-store               Don't allocate floats and doubles in extended-
                              precision registers
  -fforward-propagate         Perform a forward propagation pass on RTL
  -fgcse                      Perform global common subexpression elimination
  -fgcse-after-reload         Perform global common subexpression elimination
                              after register allocation has finished
  -fgcse-las                  Perform redundant load after store elimination in
                              global common subexpression elimination
  -fgcse-lm                   Perform enhanced load motion during global common
                              subexpression elimination
  -fgcse-sm                   Perform store motion after global common
                              subexpression elimination
  -fgraphite-identity         Enable Graphite Identity transformation
  -fguess-branch-probability  Enable guessing of branch probabilities
  -fhoist-adjacent-loads      Enable hoisting adjacent loads to encourage
                              generating conditional move instructions
  -fif-conversion             Perform conversion of conditional jumps to
                              branchless equivalents
  -fif-conversion2            Perform conversion of conditional jumps to
                              conditional execution
  -finline                    Enable inlining of function declared "inline",
                              disabling disables all inlining
  -finline-atomics            Inline __atomic operations when a lock free
                              instruction sequence is available.
  -finline-functions-called-once Integrate functions only required by their
                              single caller
  -finline-small-functions    Integrate functions into their callers when code
                              size is known not to grow
  -fipa-cp                    Perform Interprocedural constant propagation
  -fipa-cp-clone              Perform cloning to make Interprocedural constant
                              propagation stronger
  -fipa-profile               Perform interprocedural profile propagation
  -fipa-pta                   Perform interprocedural points-to analysis
  -fipa-pure-const            Discover pure and const functions
  -fipa-reference             Discover readonly and non addressable static
                              variables
  -fipa-sra                   Perform interprocedural reduction of aggregates
  -fira-hoist-pressure        Use IRA based register pressure calculation in
                              RTL hoist optimizations.
  -fivopts                    Optimize induction variables on trees
  -fjump-tables               Use jump tables for sufficiently large switch
                              statements
  -floop-block                Enable Loop Blocking transformation
  -floop-interchange          Enable Loop Interchange transformation
  -floop-nest-optimize        Enable the ISL based loop nest optimizer
  -floop-parallelize-all      Mark all loops as parallel
  -floop-strip-mine           Enable Loop Strip Mining transformation
  -fmath-errno                Set errno after built-in math functions
  -fmerge-all-constants       Attempt to merge identical constants and constant
                              variables
  -fmerge-constants           Attempt to merge identical constants across
                              compilation units
  -fmodulo-sched              Perform SMS based modulo scheduling before the
                              first scheduling pass
  -fmove-loop-invariants      Move loop invariant computations out of loops
  -fnon-call-exceptions       Support synchronous non-call exceptions
  -fomit-frame-pointer        When possible do not generate stack frames
  -fopt-info                  Enable all optimization info dumps on stderr
  -foptimize-register-move    Do the full register move optimization pass
  -foptimize-sibling-calls    Optimize sibling and tail recursive calls
  -foptimize-strlen           Enable string length optimizations on trees
  -fpack-struct               Pack structure members together without holes
  -fpack-struct=<number>      Set initial maximum structure member alignment
  -fpeel-loops                Perform loop peeling
  -fpeephole                  Enable machine specific peephole optimizations
  -fpeephole2                 Enable an RTL peephole pass before sched2
  -fpredictive-commoning      Run predictive commoning optimization.
  -fprefetch-loop-arrays      Generate prefetch instructions, if available, for
                              arrays in loops
  -freg-struct-return         Return small aggregates in registers
  -fregmove                   Enables a register move optimization
  -frename-registers          Perform a register renaming optimization pass
  -freorder-blocks            Reorder basic blocks to improve code placement
  -freorder-blocks-and-partition Reorder basic blocks and partition into hot
                              and cold sections
  -freorder-functions         Reorder functions to improve code placement
  -frerun-cse-after-loop      Add a common subexpression elimination pass after
                              loop optimizations
  -freschedule-modulo-scheduled-loops Enable/Disable the traditional scheduling
                              in loops that already passed modulo scheduling
  -frounding-math             Disable optimizations that assume default FP
                              rounding behavior
  -fsched-critical-path-heuristic Enable the critical path heuristic in the
                              scheduler
  -fsched-dep-count-heuristic Enable the dependent count heuristic in the
                              scheduler
  -fsched-group-heuristic     Enable the group heuristic in the scheduler
  -fsched-interblock          Enable scheduling across basic blocks
  -fsched-last-insn-heuristic Enable the last instruction heuristic in the
                              scheduler
  -fsched-pressure            Enable register pressure sensitive insn scheduling
  -fsched-rank-heuristic      Enable the rank heuristic in the scheduler
  -fsched-spec                Allow speculative motion of non-loads
  -fsched-spec-insn-heuristic Enable the speculative instruction heuristic in
                              the scheduler
  -fsched-spec-load           Allow speculative motion of some loads
  -fsched-spec-load-dangerous Allow speculative motion of more loads
  -fsched-stalled-insns       Allow premature scheduling of queued insns
  -fsched-stalled-insns-dep   Set dependence distance checking in premature
                              scheduling of queued insns
  -fsched2-use-superblocks    If scheduling post reload, do superblock
                              scheduling
  -fschedule-insns            Reschedule instructions before register allocation
  -fschedule-insns2           Reschedule instructions after register allocation
  -fsection-anchors           Access data in the same section from shared
                              anchor points
  -fsel-sched-pipelining      Perform software pipelining of inner loops during
                              selective scheduling
  -fsel-sched-pipelining-outer-loops Perform software pipelining of outer loops
                              during selective scheduling
  -fsel-sched-reschedule-pipelined Reschedule pipelined regions without
                              pipelining
  -fselective-scheduling      Schedule instructions using selective scheduling
                              algorithm
  -fselective-scheduling2     Run selective scheduling after reload
  -fset-stack-executable      For nested functions on stack executable
                              permission is set.
  -fshrink-wrap               Emit function prologues only before parts of the
                              function that need it, rather than at the top of
                              the function.
  -fsignaling-nans            Disable optimizations observable by IEEE
                              signaling NaNs
  -fsigned-zeros              Disable floating point optimizations that ignore
                              the IEEE signedness of zero
  -fsingle-precision-constant Convert floating point constants to single
                              precision constants
  -fsplit-ivs-in-unroller     Split lifetimes of induction variables when loops
                              are unrolled
  -fsplit-wide-types          Split wide types into independent registers
  -fstrict-aliasing           Assume strict aliasing rules apply
  -fthread-jumps              Perform jump threading optimizations
  -ftoplevel-reorder          Reorder top level functions, variables, and asms
  -ftrapping-math             Assume floating-point operations can trap
  -ftrapv                     Trap for signed overflow in addition, subtraction
                              and multiplication
  -ftree-bit-ccp              Enable SSA-BIT-CCP optimization on trees
  -ftree-builtin-call-dce     Enable conditional dead code elimination for
                              builtin calls
  -ftree-ccp                  Enable SSA-CCP optimization on trees
  -ftree-ch                   Enable loop header copying on trees
  -ftree-coalesce-inlined-vars Enable coalescing of copy-related user variables
                              that are inlined
  -ftree-coalesce-vars        Enable coalescing of all copy-related user
                              variables
  -ftree-copy-prop            Enable copy propagation on trees
  -ftree-copyrename           Replace SSA temporaries with better names in
                              copies
  -ftree-cselim               Transform condition stores into unconditional ones
  -ftree-dce                  Enable SSA dead code elimination optimization on
                              trees
  -ftree-dominator-opts       Enable dominator optimizations
  -ftree-dse                  Enable dead store elimination
  -ftree-forwprop             Enable forward propagation on trees
  -ftree-fre                  Enable Full Redundancy Elimination (FRE) on trees
  -ftree-loop-distribute-patterns Enable loop distribution for patterns
                              transformed into a library call
  -ftree-loop-distribution    Enable loop distribution on trees
  -ftree-loop-if-convert      Convert conditional jumps in innermost loops to
                              branchless equivalents
  -ftree-loop-if-convert-stores Also if-convert conditional jumps containing
                              memory writes
  -ftree-loop-im              Enable loop invariant motion on trees
  -ftree-loop-ivcanon         Create canonical induction variables in loops
  -ftree-loop-optimize        Enable loop optimizations on tree level
  -ftree-lrs                  Perform live range splitting during the SSA-
                              >normal pass
  -ftree-partial-pre          In SSA-PRE optimization on trees, enable partial-
                              partial redundancy elimination
  -ftree-phiprop              Enable hoisting loads from conditional pointers.
  -ftree-pre                  Enable SSA-PRE optimization on trees
  -ftree-pta                  Perform function-local points-to analysis on
                              trees.
  -ftree-reassoc              Enable reassociation on tree level
  -ftree-scev-cprop           Enable copy propagation of scalar-evolution
                              information.
  -ftree-sink                 Enable SSA code sinking on trees
  -ftree-slp-vectorize        Enable basic block vectorization (SLP) on trees
  -ftree-slsr                 Perform straight-line strength reduction
  -ftree-sra                  Perform scalar replacement of aggregates
  -ftree-switch-conversion    Perform conversions of switch initializations.
  -ftree-tail-merge           Enable tail merging on trees
  -ftree-ter                  Replace temporary expressions in the SSA->normal
                              pass
  -ftree-vect-loop-version    Enable loop versioning when doing loop
                              vectorization on trees
  -ftree-vectorize            Enable loop vectorization on trees
  -ftree-vrp                  Perform Value Range Propagation on trees
  -funit-at-a-time            Compile whole compilation unit at a time
  -funroll-all-loops          Perform loop unrolling for all loops
  -funroll-loops              Perform loop unrolling when iteration count is
                              known
  -funsafe-loop-optimizations Allow loop optimizations to assume that the loops
                              behave in normal way
  -funsafe-math-optimizations Allow math optimizations that may violate IEEE or
                              ISO standards
  -funswitch-loops            Perform loop unswitching
  -funwind-tables             Just generate unwind tables for exception handling
  -fvar-tracking              Perform variable tracking
  -fvar-tracking-assignments  Perform variable tracking by annotating
                              assignments
  -fvar-tracking-assignments-toggle Toggle -fvar-tracking-assignments
  -fvar-tracking-uninit       Perform variable tracking and also tag variables
                              that are uninitialized
  -fvariable-expansion-in-unroller Apply variable expansion when loops are
                              unrolled
  -fvect-cost-model           Enable use of cost model in vectorization
  -fvpt                       Use expression value profiles in optimizations
  -fweb                       Construct webs and split unrelated uses of single
                              variable
  -fwhole-program             Perform whole program optimizations
  -fwrapv                     Assume signed arithmetic overflow wraps around

The following options are target specific:
  -m128bit-long-double        sizeof(long double) is 16
  -m32                        Generate 32bit i386 code
  -m3dnow                     Support 3DNow! built-in functions
  -m3dnowa                    Support Athlon 3Dnow! built-in functions
  -m64                        Generate 64bit x86-64 code
  -m80387                     Use hardware fp
  -m8bit-idiv                 Expand 32bit/64bit integer divide into 8bit
                              unsigned integer divide with run-time check
  -m96bit-long-double         sizeof(long double) is 12
  -mabi=                      Generate code that conforms to the given ABI
  -mabm                       Support code generation of Advanced Bit
                              Manipulation (ABM) instructions.
  -maccumulate-outgoing-args  Reserve space for outgoing arguments in the
                              function prologue
  -maddress-mode=             Use given address mode
  -madx                       Support flag-preserving add-carry instructions
  -maes                       Support AES built-in functions and code generation
  -malign-double              Align some doubles on dword boundary
  -malign-functions=          Function starts are aligned to this power of 2
  -malign-jumps=              Jump targets are aligned to this power of 2
  -malign-loops=              Loop code aligned to this power of 2
  -malign-stringops           Align destination of the string operations
  -march=                     Generate code for given CPU
  -masm=                      Use given assembler dialect
  -mavx                       Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1,
                              SSE4.2 and AVX built-in functions and code
                              generation
  -mavx2                      Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1,
                              SSE4.2, AVX and AVX2 built-in functions and code
                              generation
  -mavx256-split-unaligned-load Split 32-byte AVX unaligned load
  -mavx256-split-unaligned-store Split 32-byte AVX unaligned store
  -mbmi                       Support BMI built-in functions and code generation
  -mbmi2                      Support BMI2 built-in functions and code
                              generation
  -mbranch-cost=              Branches are this expensive (1-5, arbitrary units)
  -mcld                       Generate cld instruction in the function prologue.
  -mcmodel=                   Use given x86-64 code model
  -mconsole                   Create console application
  -mcpu=                      This switch lacks documentation
  -mcrc32                     Support code generation of crc32 instruction.
  -mcx16                      Support code generation of cmpxchg16b instruction.
  -mdispatch-scheduler        Do dispatch scheduling if processor is bdver1 or
                              bdver2 or bdver3 and Haifa scheduling is selected.
  -mdll                       Generate code for a DLL
  -mf16c                      Support F16C built-in functions and code
                              generation
  -mfancy-math-387            Generate sin, cos, sqrt for FPU
  -mfentry                    Emit profiling counter call at function entry
                              before prologue.
  -mfma                       Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1,
                              SSE4.2, AVX and FMA built-in functions and code
                              generation
  -mfma4                      Support FMA4 built-in functions and code
                              generation 
  -mforce-drap                Always use Dynamic Realigned Argument Pointer
                              (DRAP) to realign stack
  -mfp-ret-in-387             Return values of functions in FPU registers
  -mfpmath=                   Generate floating point mathematics using given
                              instruction set
  -mfsgsbase                  Support FSGSBASE built-in functions and code
                              generation
  -mfused-madd                This switch lacks documentation
  -mfxsr                      Support FXSAVE and FXRSTOR instructions
  -mhard-float                Use hardware fp
  -mhle                       Support Hardware Lock Elision prefixes
  -mieee-fp                   Use IEEE math for fp comparisons
  -mincoming-stack-boundary=  Assume incoming stack aligned to this power of 2
  -minline-all-stringops      Inline all known string operations
  -minline-stringops-dynamically Inline memset/memcpy string operations, but
                              perform inline version only for small blocks
  -mintel-syntax              This switch lacks documentation
  -mlarge-data-threshold=     Data greater than given threshold will go into
                              .ldata section in x86-64 medium model
  -mlong-double-64            Use 64-bit long double
  -mlong-double-80            Use 80-bit long double
  -mlwp                       Support LWP built-in functions and code
                              generation 
  -mlzcnt                     Support LZCNT built-in function and code
                              generation
  -mmmx                       Support MMX built-in functions
  -mmovbe                     Support code generation of movbe instruction.
  -mms-bitfields              Use native (MS) bitfield layout
  -mno-align-stringops        This switch lacks documentation
  -mno-fancy-math-387         This switch lacks documentation
  -mno-push-args              This switch lacks documentation
  -mno-red-zone               This switch lacks documentation
  -mno-sse4                   Do not support SSE4.1 and SSE4.2 built-in
                              functions and code generation
  -mnop-fun-dllimport         Ignore dllimport for functions
  -momit-leaf-frame-pointer   Omit the frame pointer in leaf functions
  -mpc32                      Set 80387 floating-point precision to 32-bit
  -mpc64                      Set 80387 floating-point precision to 64-bit
  -mpc80                      Set 80387 floating-point precision to 80-bit
  -mpclmul                    Support PCLMUL built-in functions and code
                              generation
  -mpe-aligned-commons        Use the GNU extension to the PE format for
                              aligned common data
  -mpopcnt                    Support code generation of popcnt instruction.
  -mprefer-avx128             Use 128-bit AVX instructions instead of 256-bit
                              AVX instructions in the auto-vectorizer.
  -mpreferred-stack-boundary= Attempt to keep stack aligned to this power of 2
  -mprfchw                    Support PREFETCHW instruction
  -mpush-args                 Use push instructions to save outgoing arguments
  -mrdrnd                     Support RDRND built-in functions and code
                              generation
  -mrdseed                    Support RDSEED instruction
  -mrecip                     Generate reciprocals instead of divss and sqrtss.
  -mrecip=                    Control generation of reciprocal estimates.
  -mred-zone                  Use red-zone in the x86-64 code
  -mregparm=                  Number of registers used to pass integer arguments
  -mrtd                       Alternate calling convention
  -mrtm                       Support RTM built-in functions and code generation
  -msahf                      Support code generation of sahf instruction in
                              64bit x86-64 code.
  -msoft-float                Do not use hardware fp
  -msse                       Support MMX and SSE built-in functions and code
                              generation
  -msse2                      Support MMX, SSE and SSE2 built-in functions and
                              code generation
  -msse2avx                   Encode SSE instructions with VEX prefix
  -msse3                      Support MMX, SSE, SSE2 and SSE3 built-in
                              functions and code generation
  -msse4                      Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1 and
                              SSE4.2 built-in functions and code generation
  -msse4.1                    Support MMX, SSE, SSE2, SSE3, SSSE3 and SSE4.1
                              built-in functions and code generation
  -msse4.2                    Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1 and
                              SSE4.2 built-in functions and code generation
  -msse4a                     Support MMX, SSE, SSE2, SSE3 and SSE4A built-in
                              functions and code generation
  -msse5                      This switch lacks documentation
  -msseregparm                Use SSE register passing conventions for SF and
                              DF mode
  -mssse3                     Support MMX, SSE, SSE2, SSE3 and SSSE3 built-in
                              functions and code generation
  -mstack-arg-probe           Enable stack probing
  -mstackrealign              Realign stack in prologue
  -mstringop-strategy=        Chose strategy to generate stringop using
  -mtbm                       Support TBM built-in functions and code generation
  -mthreads                   Use Mingw-specific thread support
  -mtls-dialect=              Use given thread-local storage dialect
  -mtls-direct-seg-refs       Use direct references against %gs when accessing
                              tls data
  -mtune=                     Schedule code for given CPU
  -mveclibabi=                Vector library ABI to use
  -mvect8-ret-in-mem          Return 8-byte vectors in memory
  -mvzeroupper                Generate vzeroupper instruction before a transfer
                              of control flow out of the function.
  -mwin32                     Set Windows defines
  -mwindows                   Create GUI application
  -mx32                       Generate 32bit x86-64 code
  -mxop                       Support XOP built-in functions and code
                              generation 
  -mxsave                     Support XSAVE and XRSTOR instructions
  -mxsaveopt                  Support XSAVEOPT instruction

  Known assembler dialects (for use with the -masm-dialect= option):
    att intel

  Known ABIs (for use with the -mabi= option):
    ms sysv

  Known code models (for use with the -mcmodel= option):
    32 kernel large medium small

  Valid arguments to -mfpmath=:
    387 387+sse 387,sse both sse sse+387 sse,387

  Known vectorization library ABIs (for use with the -mveclibabi= option):
    acml svml

  Known address mode (for use with the -maddress-mode= option):
    long short

  Valid arguments to -mstringop-strategy=:
    byte_loop libcall loop rep_4byte rep_8byte rep_byte unrolled_loop

  Known TLS dialects (for use with the -mtls-dialect= option):
    gnu gnu2

The following options are language-independent:
  --debug                     This switch lacks documentation
  --dumpbase                  This switch lacks documentation
  --dumpdir                   This switch lacks documentation
  --help                      Display this information
  --help=<class>              Display descriptions of a specific class of
                              options.  <class> is one or more of optimizers,
                              target, warnings, undocumented, params
  --optimize                  This switch lacks documentation
  --param <param>=<value>     Set parameter <param> to value.  See below for a
                              complete list of parameters
  --param=                    This switch lacks documentation
  --pedantic-errors           This switch lacks documentation
  --profile                   This switch lacks documentation
  --target-help               Alias for --help=target
  --version                   This switch lacks documentation
  -Werror=                    Treat specified warning as error
  -Wfatal-errors              Exit on the first error occurred
  -Wframe-larger-than=<number> Warn if a function's stack frame requires more
                              than <number> bytes
  -Wmissing-noreturn          This switch lacks documentation
  -Wunreachable-code          Does nothing. Preserved for backward
                              compatibility.
  -aux-info <file>            Emit declaration information into <file>
  -aux-info=                  This switch lacks documentation
  -auxbase                    This switch lacks documentation
  -auxbase-strip              This switch lacks documentation
  -dumpbase <file>            Set the file basename to be used for dumps
  -dumpdir <dir>              Set the directory name to be used for dumps
  -fPIC                       Generate position-independent code if possible
                              (large mode)
  -fPIE                       Generate position-independent code for
                              executables if possible (large mode)
  -fabi-version=              This switch lacks documentation
  -falign-functions=          This switch lacks documentation
  -falign-jumps=              This switch lacks documentation
  -falign-labels=             This switch lacks documentation
  -falign-loops=              This switch lacks documentation
  -fargument-alias            Does nothing. Preserved for backward
                              compatibility.
  -fargument-noalias          Does nothing. Preserved for backward
                              compatibility.
  -fargument-noalias-anything Does nothing. Preserved for backward
                              compatibility.
  -fargument-noalias-global   Does nothing. Preserved for backward
                              compatibility.
  -fassociative-math          Allow optimization for floating-point arithmetic
                              which may change the result of the operation due
                              to rounding.
  -fauto-inc-dec              Generate auto-inc/dec instructions
  -fbounds-check              Generate code to check bounds before indexing
                              arrays
  -fcall-saved-<register>     Mark <register> as being preserved across
                              functions
  -fcall-used-<register>      Mark <register> as being corrupted by function
                              calls
  -fcheck-data-deps           Compare the results of several data dependence
                              analyzers.
  -fcompare-debug-second      Run only the second compilation of -fcompare-debug
  -fcompare-debug[=<opts>]    Compile with and without e.g. -gtoggle, and
                              compare the final-insns dump
  -fcse-skip-blocks           Does nothing.  Preserved for backward
                              compatibility.
  -fdbg-cnt-list              List all available debugging counters with their
                              limits and counts.
  -fdbg-cnt=<counter>:<limit>[,<counter>:<limit>,...] Set the debug counter
                              limit.   
  -fdebug-prefix-map=         Map one directory name to another in debug
                              information
  -fdebug-types-section       Output .debug_types section when using DWARF v4
                              debuginfo.
  -fdelete-dead-exceptions    Delete dead instructions that may throw exceptions
  -fdiagnostics-show-caret    Show the source line with a caret indicating the
                              column
  -fdiagnostics-show-location=[once|every-line] How often to emit source
                              location at the beginning of line-wrapped
                              diagnostics
  -fdiagnostics-show-option   Amend appropriate diagnostic messages with the
                              command line option that controls them
  -fdisable-                  -fdisable-[tree|rtl|ipa]-<pass>=range1+range2
                              disables an optimization pass
  -fdump-<type>               Dump various compiler internals to a file
  -fdump-final-insns=filename Dump to filename the insns at the end of
                              translation
  -fdump-go-spec=filename     Write all declarations to file as Go code
  -fdump-noaddr               Suppress output of addresses in debugging dumps
  -fdump-passes               Dump optimization passes
  -fdump-unnumbered           Suppress output of instruction numbers, line
                              number notes and addresses in debugging dumps
  -fdump-unnumbered-links     Suppress output of previous and next insn numbers
                              in debugging dumps
  -fdwarf2-cfi-asm            Enable CFI tables via GAS assembler directives.
  -feliminate-dwarf2-dups     Perform DWARF2 duplicate elimination
  -feliminate-unused-debug-symbols Perform unused type elimination in debug info
  -feliminate-unused-debug-types Perform unused type elimination in debug info
  -femit-class-debug-always   Do not suppress C++ class debug information.
  -fenable-                   -fenable-[tree|rtl|ipa]-<pass>=range1+range2
                              enables an optimization pass
  -fexcess-precision=[fast|standard] Specify handling of excess floating-point
                              precision
  -ffast-math                 This switch lacks documentation
  -ffat-lto-objects           Output lto objects containing both the
                              intermediate language and binary output.
  -ffixed-<register>          Mark <register> as being unavailable to the
                              compiler
  -fforce-addr                Does nothing.  Preserved for backward
                              compatibility.
  -ffp-contract=              -ffp-contract=[off|on|fast] Perform floating-
                              point expression contraction.
  -ffunction-cse              Allow function addresses to be held in registers
  -ffunction-sections         Place each function into its own section
  -fgnu-tm                    Enable support for GNU transactional memory
  -fgraphite                  Enable in and out of Graphite representation
  -fhelp                      This switch lacks documentation
  -fhelp=                     This switch lacks documentation
  -fident                     Process #ident directives
  -findirect-inlining         Perform indirect inlining
  -finhibit-size-directive    Do not generate .size directives
  -finline-limit-             This switch lacks documentation
  -finline-limit=<number>     Limit the size of inlined functions to <number>
  -finstrument-functions      Instrument function entry and exit with profiling
                              calls
  -finstrument-functions-exclude-file-list= -finstrument-functions-exclude-file-
                              list=filename,...  Do not instrument functions
                              listed in files
  -finstrument-functions-exclude-function-list= -finstrument-functions-exclude-
                              function-list=name,...  Do not instrument listed
                              functions
  -fipa-matrix-reorg          Does nothing. Preserved for backward
                              compatibility.
  -fipa-struct-reorg          Does nothing. Preserved for backward
                              compatibility.
  -fira-algorithm=            -fira-algorithm=[CB|priority] Set the used IRA
                              algorithm
  -fira-loop-pressure         Use IRA based register pressure calculation in
                              RTL loop optimizations.
  -fira-region=               -fira-region=[one|all|mixed] Set regions for IRA
  -fira-share-save-slots      Share slots for saving different hard registers.
  -fira-share-spill-slots     Share stack slots for spilled pseudo-registers.
  -fira-verbose=<number>      Control IRA's level of diagnostic messages.
  -fkeep-inline-functions     Generate code for functions even if they are
                              fully inlined
  -fkeep-static-consts        Emit static const variables even if they are not
                              used
  -fleading-underscore        Give external symbols a leading underscore
  -floop-flatten              Does nothing. Preserved for backward
                              compatibility.
  -floop-optimize             Does nothing.  Preserved for backward
                              compatibility.
  -flto                       Enable link-time optimization.
  -flto-compression-level=<number> Use zlib compression level <number> for IL
  -flto-partition=1to1        Partition symbols and vars at linktime based on
                              object files they originate from
  -flto-partition=balanced    Partition functions and vars at linktime into
                              approximately same sized buckets
  -flto-partition=max         Put every symbol into separate partition
  -flto-partition=none        Disable partioning and streaming
  -flto-report                Report various link-time optimization statistics
  -flto=                      Link-time optimization with number of parallel
                              jobs or jobserver.
  -fmax-errors=<number>       Maximum number of errors to report
  -fmem-report                Report on permanent memory allocation
  -fmem-report-wpa            Report on permanent memory allocation in WPA only
  -fmerge-debug-strings       Attempt to merge identical debug strings across
                              compilation units
  -fmessage-length=<number>   Limit diagnostics to <number> characters per
                              line.  0 suppresses line-wrapping
  -fmodulo-sched-allow-regmoves Perform SMS based modulo scheduling with
                              register moves allowed
  -fopt-info[-<type>=filename] Dump compiler optimization details
  -fpartial-inlining          Perform partial inlining
  -fpcc-struct-return         Return small aggregates in memory, not registers
  -fpic                       Generate position-independent code if possible
                              (small mode)
  -fpie                       Generate position-independent code for
                              executables if possible (small mode)
  -fplugin-arg-<name>-<key>[=<value>] Specify argument <key>=<value> for plugin
                              <name>
  -fplugin=                   Specify a plugin to load
  -fpost-ipa-mem-report       Report on memory allocation before
                              interprocedural optimization
  -fpre-ipa-mem-report        Report on memory allocation before
                              interprocedural optimization
  -fprofile                   Enable basic program profiling code
  -fprofile-arcs              Insert arc-based program profiling code
  -fprofile-correction        Enable correction of flow inconsistent profile
                              data input
  -fprofile-dir=              Set the top-level directory for storing the
                              profile data. The default is 'pwd'.
  -fprofile-generate          Enable common options for generating profile info
                              for profile feedback directed optimizations
  -fprofile-generate=         Enable common options for generating profile info
                              for profile feedback directed optimizations, and
                              set -fprofile-dir=
  -fprofile-report            Report on consistency of profile
  -fprofile-use               Enable common options for performing profile
                              feedback directed optimizations
  -fprofile-use=              Enable common options for performing profile
                              feedback directed optimizations, and set
                              -fprofile-dir=
  -fprofile-values            Insert code to profile values of expressions
  -frandom-seed               This switch lacks documentation
  -frandom-seed=<string>      Make compile reproducible using <string>
  -freciprocal-math           Same as -fassociative-math for expressions which
                              include division.
  -frecord-gcc-switches       Record gcc command line switches in the object
                              file.
  -free                       Turn on Redundant Extensions Elimination pass.
  -frerun-loop-opt            Does nothing.  Preserved for backward
                              compatibility.
  -fsanitize=address          Enable AddressSanitizer, a memory error detector
  -fsanitize=thread           Enable ThreadSanitizer, a data race detector
  -fsched-stalled-insns-dep=<number> Set dependence distance checking in
                              premature scheduling of queued insns
  -fsched-stalled-insns=<number> Set number of queued insns that can be
                              prematurely scheduled
  -fsched-verbose=<number>    Set the verbosity level of the scheduler
  -fsched2-use-traces         Does nothing.  Preserved for backward
                              compatibility.
  -fsee                       Does nothing.  Preserved for backward
                              compatibility.
  -fshow-column               Show column numbers in diagnostics, when
                              available.  Default on
  -fsplit-stack               Generate discontiguous stack frames
  -fstack-check               Insert stack checking code into the program. 
                              Same as -fstack-check=specific
  -fstack-check=[no|generic|specific] Insert stack checking code into the
                              program
  -fstack-limit               This switch lacks documentation
  -fstack-limit-register=<register> Trap if the stack goes past <register>
  -fstack-limit-symbol=<name> Trap if the stack goes past symbol <name>
  -fstack-protector           Use propolice as a stack protection method
  -fstack-protector-all       Use a stack protection method for every function
  -fstack-reuse=              -fstack-reuse=[all|named_vars|none] Set stack
                              reuse level for local variables.
  -fstack-usage               Output stack usage information on a per-function
                              basis
  -fstrength-reduce           Does nothing.  Preserved for backward
                              compatibility.
  -fstrict-overflow           Treat signed overflow as undefined
  -fstrict-volatile-bitfields Force bitfield accesses to match their type width
  -fsync-libcalls             Implement __atomic operations via libcalls to
                              legacy __sync functions
  -fsyntax-only               Check for syntax errors, then stop
  -ftarget-help               This switch lacks documentation
  -ftest-coverage             Create data files needed by "gcov"
  -ftime-report               Report the time taken by each compiler pass
  -ftls-model=[global-dynamic|local-dynamic|initial-exec|local-exec] Set the
                              default thread-local storage code generation model
  -ftracer                    Perform superblock formation via tail duplication
  -ftree-loop-linear          Enable loop interchange transforms.  Same as
                              -floop-interchange
  -ftree-parallelize-loops=   Enable automatic parallelization of loops
  -ftree-salias               Does nothing.  Preserved for backward
                              compatibility.
  -ftree-store-ccp            Does nothing.  Preserved for backward
                              compatibility.
  -ftree-store-copy-prop      Does nothing.  Preserved for backward
                              compatibility.
  -ftree-vectorizer-verbose=<number> This switch is deprecated. Use -fopt-info
                              instead.
  -fuse-ld=bfd                Use the bfd linker instead of the default linker
  -fuse-ld=gold               Use the gold linker instead of the default linker
  -fuse-linker-plugin         This switch lacks documentation
  -fverbose-asm               Add extra commentary to assembler output
  -fversion                   This switch lacks documentation
  -fvisibility=[default|internal|hidden|protected] Set the default symbol
                              visibility
  -fwritable-relocated-rdata  Put relocated read-only data into .data section.
  -fzee                       Does nothing.  Preserved for backward
                              compatibility.
  -fzero-initialized-in-bss   Put zero initialized data in the bss section
  -g                          Generate debug information in default format
  -gcoff                      Generate debug information in COFF format
  -gdwarf-                    Generate debug information in DWARF v2 (or later)
                              format
  -ggdb                       Generate debug information in default extended
                              format
  -gno-pubnames               Don't generate DWARF pubnames and pubtypes
                              sections.
  -gno-record-gcc-switches    Don't record gcc command line switches in DWARF
                              DW_AT_producer.
  -gno-split-dwarf            Don't generate debug information in separate .dwo
                              files
  -gno-strict-dwarf           Emit DWARF additions beyond selected version
  -gpubnames                  Generate DWARF pubnames and pubtypes sections.
  -grecord-gcc-switches       Record gcc command line switches in DWARF
                              DW_AT_producer.
  -gsplit-dwarf               Generate debug information in separate .dwo files
  -gstabs                     Generate debug information in STABS format
  -gstabs+                    Generate debug information in extended STABS
                              format
  -gstrict-dwarf              Don't emit DWARF additions beyond selected version
  -gtoggle                    Toggle debug information generation
  -gvms                       Generate debug information in VMS format
  -gxcoff                     Generate debug information in XCOFF format
  -gxcoff+                    Generate debug information in extended XCOFF
                              format
  -imultiarch <dir>           Set <dir> to be the multiarch include subdirectory
  -iplugindir=<dir>           Set <dir> to be the default plugin directory
  -p                          Enable function profiling
  -pedantic-errors            Like -pedantic but issue them as errors
  -quiet                      Do not display functions compiled or elapsed time

Usage: c:/mingw/bin/../lib/gcc/mingw32/4.8.1/../../../../mingw32/bin/as.exe [option...] [asmfile...]
Options:
  -a[sub-option...]	  turn on listings
                      	  Sub-options [default hls]:
                      	  c      omit false conditionals
                      	  d      omit debugging directives
                      	  g      include general info
                      	  h      include high-level source
                      	  l      include assembly
                      	  m      include macro expansions
                      	  n      omit forms processing
                      	  s      include symbols
                      	  =FILE  list to FILE (must be last sub-option)
  --alternate             initially turn on alternate macro syntax
  -D                      produce assembler debugging messages
  --debug-prefix-map OLD=NEW
                          map OLD to NEW in debug information
  --defsym SYM=VAL        define symbol SYM to given value
  -f                      skip whitespace and comment preprocessing
  -g --gen-debug          generate debugging information
  --gstabs                generate STABS debugging information
  --gstabs+               generate STABS debug info with GNU extensions
  --gdwarf-2              generate DWARF2 debugging information
  --gdwarf-sections       generate per-function section names for DWARF line information
  --hash-size=<value>     set the hash table size close to <value>
  --help                  show this message and exit
  --target-help           show target specific options
  -I DIR                  add DIR to search list for .include directives
  -J                      don't warn about signed overflow
  -K                      warn when differences altered for long displacements
  -L,--keep-locals        keep local symbols (e.g. starting with `L')
  -M,--mri                assemble in MRI compatibility mode
  --MD FILE               write dependency information in FILE (default none)
  -nocpp                  ignored
  -o OBJFILE              name the object-file output OBJFILE (default a.out)
  -R                      fold data section into text section
  --reduce-memory-overheads 
                          prefer smaller memory use at the cost of longer
                          assembly times
  --statistics            print various measured statistics from execution
  --strip-local-absolute  strip local absolute symbols
  --traditional-format    Use same format as native assembler when possible
  --version               print assembler version number and exit
  -W  --no-warn           suppress warnings
  --warn                  don't suppress warnings
  --fatal-warnings        treat warnings as errors
  -w                      ignored
  -X                      ignored
  -Z                      generate object file even after errors
  --listing-lhs-width     set the width in words of the output data column of
                          the listing
  --listing-lhs-width2    set the width in words of the continuation lines
                          of the output data column; ignored if smaller than
                          the width of the first line
  --listing-rhs-width     set the max width in characters of the lines from
                          the source file
  --listing-cont-lines    set the maximum number of continuation lines used
                          for the output data column of the listing
  @FILE                   read options from FILE
  -n                      Do not optimize code alignment
  -q                      quieten some warnings
  --32/--64/--x32         generate 32bit/64bit/x32 code
  --divide                ignored
  -march=CPU[,+EXTENSION...]
                          generate code for CPU and EXTENSION, CPU is one of:
                           generic32, generic64, i386, i486, i586, i686,
                           pentium, pentiumpro, pentiumii, pentiumiii, pentium4,
                           prescott, nocona, core, core2, corei7, l1om, k1om,
                           k6, k6_2, athlon, opteron, k8, amdfam10, bdver1,
                           bdver2, bdver3, btver1, btver2
                          EXTENSION is combination of:
                           8087, 287, 387, no87, mmx, nommx, sse, sse2, sse3,
                           ssse3, sse4.1, sse4.2, sse4, nosse, avx, avx2,
                           avx512f, avx512cd, avx512er, avx512pf, noavx, vmx,
                           vmfunc, smx, xsave, xsaveopt, aes, pclmul, fsgsbase,
                           rdrnd, f16c, bmi2, fma, fma4, xop, lwp, movbe, cx16,
                           ept, lzcnt, hle, rtm, invpcid, clflush, nop, syscall,
                           rdtscp, 3dnow, 3dnowa, padlock, svme, sse4a, abm,
                           bmi, tbm, adx, rdseed, prfchw, smap, mpx, sha
  -mtune=CPU              optimize for CPU, CPU is one of:
                           generic32, generic64, i8086, i186, i286, i386, i486,
                           i586, i686, pentium, pentiumpro, pentiumii,
                           pentiumiii, pentium4, prescott, nocona, core, core2,
                           corei7, l1om, k1om, k6, k6_2, athlon, opteron, k8,
                           amdfam10, bdver1, bdver2, bdver3, btver1, btver2
  -msse2avx               encode SSE instructions with VEX prefix
  -msse-check=[none|error|warning]
                          check SSE instructions
  -moperand-check=[none|error|warning]
                          check operand combinations for validity
  -mavxscalar=[128|256]   encode scalar AVX instructions with specific vector
                           length
  -mevexlig=[128|256|512] encode scalar EVEX instructions with specific vector
                           length
  -mevexwig=[0|1]         encode EVEX instructions with specific EVEX.W value
                           for EVEX.W bit ignored instructions
  -mmnemonic=[att|intel]  use AT&T/Intel mnemonic
  -msyntax=[att|intel]    use AT&T/Intel syntax
  -mindex-reg             support pseudo index registers
  -mnaked-reg             don't require `%' prefix for registers
  -mold-gcc               support old (<= 2.8.1) versions of gcc
  -madd-bnd-prefix        add BND prefix for all valid branches

Report bugs to <http://www.sourceware.org/bugzilla/>
Usage: collect2 [options]
 Wrap linker and generate constructor code if needed.
 Options:
  -debug          Enable debug output
  --help          Display this information
  -v, --version   Display this program's version number

Overview: http://gcc.gnu.org/onlinedocs/gccint/Collect2.html
Report bugs: <http://gcc.gnu.org/bugs.html>

Usage: c:/mingw/bin/../lib/gcc/mingw32/4.8.1/../../../../mingw32/bin/ld.exe [options] file...
Options:
  -a KEYWORD                  Shared library control for HP/UX compatibility
  -A ARCH, --architecture ARCH
                              Set architecture
  -b TARGET, --format TARGET  Specify target for following input files
  -c FILE, --mri-script FILE  Read MRI format linker script
  -d, -dc, -dp                Force common symbols to be defined
  -e ADDRESS, --entry ADDRESS Set start address
  -E, --export-dynamic        Export all dynamic symbols
  --no-export-dynamic         Undo the effect of --export-dynamic
  -EB                         Link big-endian objects
  -EL                         Link little-endian objects
  -f SHLIB, --auxiliary SHLIB Auxiliary filter for shared object symbol table
  -F SHLIB, --filter SHLIB    Filter for shared object symbol table
  -g                          Ignored
  -G SIZE, --gpsize SIZE      Small data size (if no size, same as --shared)
  -h FILENAME, -soname FILENAME
                              Set internal name of shared library
  -I PROGRAM, --dynamic-linker PROGRAM
                              Set PROGRAM as the dynamic linker to use
  -l LIBNAME, --library LIBNAME
                              Search for library LIBNAME
  -L DIRECTORY, --library-path DIRECTORY
                              Add DIRECTORY to library search path
  --sysroot=<DIRECTORY>       Override the default sysroot location
  -m EMULATION                Set emulation
  -M, --print-map             Print map file on standard output
  -n, --nmagic                Do not page align data
  -N, --omagic                Do not page align data, do not make text readonly
  --no-omagic                 Page align data, make text readonly
  -o FILE, --output FILE      Set output file name
  -O                          Optimize output file
  -plugin PLUGIN              Load named plugin
  -plugin-opt ARG             Send arg to last-loaded plugin
  -flto                       Ignored for GCC LTO option compatibility
  -flto-partition=            Ignored for GCC LTO option compatibility
  -fuse-ld=                   Ignored for GCC linker option compatibility
  -Qy                         Ignored for SVR4 compatibility
  -q, --emit-relocs           Generate relocations in final output
  -r, -i, --relocatable       Generate relocatable output
  -R FILE, --just-symbols FILE
                              Just link symbols (if directory, same as --rpath)
  -s, --strip-all             Strip all symbols
  -S, --strip-debug           Strip debugging symbols
  --strip-discarded           Strip symbols in discarded sections
  --no-strip-discarded        Do not strip symbols in discarded sections
  -t, --trace                 Trace file opens
  -T FILE, --script FILE      Read linker script
  --default-script FILE, -dT  Read default linker script
  -u SYMBOL, --undefined SYMBOL
                              Start with undefined reference to SYMBOL
  --unique [=SECTION]         Don't merge input [SECTION | orphan] sections
  -Ur                         Build global constructor/destructor tables
  -v, --version               Print version information
  -V                          Print version and emulation information
  -x, --discard-all           Discard all local symbols
  -X, --discard-locals        Discard temporary local symbols (default)
  --discard-none              Don't discard any local symbols
  -y SYMBOL, --trace-symbol SYMBOL
                              Trace mentions of SYMBOL
  -Y PATH                     Default search path for Solaris compatibility
  -(, --start-group           Start a group
  -), --end-group             End a group
  --accept-unknown-input-arch Accept input files whose architecture cannot be determined
  --no-accept-unknown-input-arch
                              Reject input files whose architecture is unknown
  --as-needed                 Only set DT_NEEDED for following dynamic libs if used
  --no-as-needed              Always set DT_NEEDED for dynamic libraries mentioned on
                                the command line
  -assert KEYWORD             Ignored for SunOS compatibility
  -Bdynamic, -dy, -call_shared
                              Link against shared libraries
  -Bstatic, -dn, -non_shared, -static
                              Do not link against shared libraries
  -Bsymbolic                  Bind global references locally
  -Bsymbolic-functions        Bind global function references locally
  --check-sections            Check section addresses for overlaps (default)
  --no-check-sections         Do not check section addresses for overlaps
  --copy-dt-needed-entries    Copy DT_NEEDED links mentioned inside DSOs that follow
  --no-copy-dt-needed-entries Do not copy DT_NEEDED links mentioned inside DSOs that follow
  --cref                      Output cross reference table
  --defsym SYMBOL=EXPRESSION  Define a symbol
  --demangle [=STYLE]         Demangle symbol names [using STYLE]
  --embedded-relocs           Generate embedded relocs
  --fatal-warnings            Treat warnings as errors
  --no-fatal-warnings         Do not treat warnings as errors (default)
  -fini SYMBOL                Call SYMBOL at unload-time
  --force-exe-suffix          Force generation of file with .exe suffix
  --gc-sections               Remove unused sections (on some targets)
  --no-gc-sections            Don't remove unused sections (default)
  --print-gc-sections         List removed unused sections on stderr
  --no-print-gc-sections      Do not list removed unused sections
  --hash-size=<NUMBER>        Set default hash table size close to <NUMBER>
  --help                      Print option help
  -init SYMBOL                Call SYMBOL at load-time
  -Map FILE                   Write a map file
  --no-define-common          Do not define Common storage
  --no-demangle               Do not demangle symbol names
  --no-keep-memory            Use less memory and more disk I/O
  --no-undefined              Do not allow unresolved references in object files
  --allow-shlib-undefined     Allow unresolved references in shared libraries
  --no-allow-shlib-undefined  Do not allow unresolved references in shared libs
  --allow-multiple-definition Allow multiple definitions
  --no-undefined-version      Disallow undefined version
  --default-symver            Create default symbol version
  --default-imported-symver   Create default symbol version for imported symbols
  --no-warn-mismatch          Don't warn about mismatched input files
  --no-warn-search-mismatch   Don't warn on finding an incompatible library
  --no-whole-archive          Turn off --whole-archive
  --noinhibit-exec            Create an output file even if errors occur
  -nostdlib                   Only use library directories specified on
                                the command line
  --oformat TARGET            Specify target of output file
  --print-output-format       Print default output format
  -qmagic                     Ignored for Linux compatibility
  --reduce-memory-overheads   Reduce memory overheads, possibly taking much longer
  --relax                     Reduce code size by using target specific optimizations
  --no-relax                  Do not use relaxation techniques to reduce code size
  --retain-symbols-file FILE  Keep only symbols listed in FILE
  -rpath PATH                 Set runtime shared library search path
  -rpath-link PATH            Set link time shared library search path
  -shared, -Bshareable        Create a shared library
  -pie, --pic-executable      Create a position independent executable
  --sort-common [=ascending|descending]
                              Sort common symbols by alignment [in specified order]
  --sort-section name|alignment
                              Sort sections by name or maximum alignment
  --spare-dynamic-tags COUNT  How many tags to reserve in .dynamic section
  --split-by-file [=SIZE]     Split output sections every SIZE octets
  --split-by-reloc [=COUNT]   Split output sections every COUNT relocs
  --stats                     Print memory usage statistics
  --target-help               Display target specific options
  --task-link SYMBOL          Do task level linking
  --traditional-format        Use same format as native linker
  --section-start SECTION=ADDRESS
                              Set address of named section
  -Tbss ADDRESS               Set address of .bss section
  -Tdata ADDRESS              Set address of .data section
  -Ttext ADDRESS              Set address of .text section
  -Ttext-segment ADDRESS      Set address of text segment
  -Trodata-segment ADDRESS    Set address of rodata segment
  -Tldata-segment ADDRESS     Set address of ldata segment
  --unresolved-symbols=<method>
                              How to handle unresolved symbols.  <method> is:
                                ignore-all, report-all, ignore-in-object-files,
                                ignore-in-shared-libs
  --verbose [=NUMBER]         Output lots of information during link
  --version-script FILE       Read version information script
  --version-exports-section SYMBOL
                              Take export symbols list from .exports, using
                                SYMBOL as the version.
  --dynamic-list-data         Add data symbols to dynamic list
  --dynamic-list-cpp-new      Use C++ operator new/delete dynamic list
  --dynamic-list-cpp-typeinfo Use C++ typeinfo dynamic list
  --dynamic-list FILE         Read dynamic list
  --warn-common               Warn about duplicate common symbols
  --warn-constructors         Warn if global constructors/destructors are seen
  --warn-multiple-gp          Warn if the multiple GP values are used
  --warn-once                 Warn only once per undefined symbol
  --warn-section-align        Warn if start of section changes due to alignment
  --warn-shared-textrel       Warn if shared object has DT_TEXTREL
  --warn-alternate-em         Warn if an object has alternate ELF machine code
  --warn-unresolved-symbols   Report unresolved symbols as warnings
  --error-unresolved-symbols  Report unresolved symbols as errors
  --whole-archive             Include all objects from following archives
  --wrap SYMBOL               Use wrapper functions for SYMBOL
  --ignore-unresolved-symbol SYMBOL
                              Unresolved SYMBOL will not cause an error or warning
  @FILE                       Read options from FILE
c:/mingw/bin/../lib/gcc/mingw32/4.8.1/../../../../mingw32/bin/ld.exe: supported targets: pe-i386 pei-i386 elf32-i386 elf32-little elf32-big srec symbolsrec verilog tekhex binary ihex
c:/mingw/bin/../lib/gcc/mingw32/4.8.1/../../../../mingw32/bin/ld.exe: supported emulations: i386pe
c:/mingw/bin/../lib/gcc/mingw32/4.8.1/../../../../mingw32/bin/ld.exe: emulation specific options:
i386pe: 
  --base_file <basefile>             Generate a base file for relocatable DLLs
  --dll                              Set image base to the default for DLLs
  --file-alignment <size>            Set file alignment
  --heap <size>                      Set initial size of the heap
  --image-base <address>             Set start address of the executable
  --major-image-version <number>     Set version number of the executable
  --major-os-version <number>        Set minimum required OS version
  --major-subsystem-version <number> Set minimum required OS subsystem version
  --minor-image-version <number>     Set revision number of the executable
  --minor-os-version <number>        Set minimum required OS revision
  --minor-subsystem-version <number> Set minimum required OS subsystem revision
  --section-alignment <size>         Set section alignment
  --stack <size>                     Set size of the initial stack
  --subsystem <name>[:<version>]     Set required OS subsystem [& version]
  --support-old-code                 Support interworking with old code
  --[no-]leading-underscore          Set explicit symbol underscore prefix mode
  --thumb-entry=<symbol>             Set the entry point to be Thumb <symbol>
  --insert-timestamp                 Use a real timestamp rather than zero.
                                     This makes binaries non-deterministic
  --add-stdcall-alias                Export symbols with and without @nn
  --disable-stdcall-fixup            Don't link _sym to _sym@nn
  --enable-stdcall-fixup             Link _sym to _sym@nn without warnings
  --exclude-symbols sym,sym,...      Exclude symbols from automatic export
  --exclude-all-symbols              Exclude all symbols from automatic export
  --exclude-libs lib,lib,...         Exclude libraries from automatic export
  --exclude-modules-for-implib mod,mod,...
                                     Exclude objects, archive members from auto
                                     export, place into import library instead.
  --export-all-symbols               Automatically export all globals to DLL
  --kill-at                          Remove @nn from exported symbols
  --out-implib <file>                Generate import library
  --output-def <file>                Generate a .DEF file for the built DLL
  --warn-duplicate-exports           Warn about duplicate exports.
  --compat-implib                    Create backward compatible import libs;
                                       create __imp_<SYMBOL> as well.
  --enable-auto-image-base           Automatically choose image base for DLLs
                                       unless user specifies one
  --disable-auto-image-base          Do not auto-choose image base. (default)
  --dll-search-prefix=<string>       When linking dynamically to a dll without
                                       an importlib, use <string><basename>.dll
                                       in preference to lib<basename>.dll 
  --enable-auto-import               Do sophisticated linking of _sym to
                                       __imp_sym for DATA references
  --disable-auto-import              Do not auto-import DATA items from DLLs
  --enable-runtime-pseudo-reloc      Work around auto-import limitations by
                                       adding pseudo-relocations resolved at
                                       runtime.
  --disable-runtime-pseudo-reloc     Do not add runtime pseudo-relocations for
                                       auto-imported DATA.
  --enable-extra-pe-debug            Enable verbose debug output when building
                                       or linking to DLLs (esp. auto-import)
  --large-address-aware              Executable supports virtual addresses
                                       greater than 2 gigabytes
  --disable-large-address-aware      Executable does not support virtual
                                       addresses greater than 2 gigabytes
  --enable-long-section-names        Use long COFF section names even in
                                       executable image files
  --disable-long-section-names       Never use long COFF section names, even
                                       in object files
  --dynamicbase			 Image base address may be relocated using
				       address space layout randomization (ASLR)
  --forceinteg		 Code integrity checks are enforced
  --nxcompat		 Image is compatible with data execution prevention
  --no-isolation		 Image understands isolation but do not isolate the image
  --no-seh			 Image does not use SEH. No SE handler may
				       be called in this image
  --no-bind			 Do not bind this image
  --wdmdriver		 Driver uses the WDM model
  --tsaware                  Image is Terminal Server aware

Report bugs to <http://www.sourceware.org/bugzilla/>

For bug reporting instructions, please see:
<http://gcc.gnu.org/bugs.html>
